ALIS  0.0.5
Develop the video games of your dreams.
ImGui.cs
1 // --------------------------------------------------------------------------
2 //
3 // █▀▀█ ░█─── ▀█▀ ░█▀▀▀█
4 // ░█▄▄█ ░█─── ░█─ ─▀▀▀▄▄
5 // ░█─░█ ░█▄▄█ ▄█▄ ░█▄▄▄█
6 //
7 // --------------------------------------------------------------------------
8 // File:ImGui.cs
9 //
10 // Author:Pablo Perdomo Falcón
11 // Web:https://www.pabllopf.dev/
12 //
13 // Copyright (c) 2021 GNU General Public License v3.0
14 //
15 // This program is free software:you can redistribute it and/or modify
16 // it under the terms of the GNU General Public License as published by
17 // the Free Software Foundation, either version 3 of the License, or
18 // (at your option) any later version.
19 //
20 // This program is distributed in the hope that it will be useful,
21 // but WITHOUT ANY WARRANTY without even the implied warranty of
22 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
23 // GNU General Public License for more details.
24 //
25 // You should have received a copy of the GNU General Public License
26 // along with this program.If not, see <http://www.gnu.org/licenses/>.
27 //
28 // --------------------------------------------------------------------------
29 
30 using System;
31 using System.Runtime.InteropServices;
32 using System.Text;
33 using Alis.Core.Aspect.Math.Vector;
39 
41 {
45  public static unsafe class ImGui
46  {
52  public static ImGuiPayloadPtr AcceptDragDropPayload(string type)
53  {
54  byte* nativeType;
55  int typeByteCount = 0;
56  if (type != null)
57  {
58  typeByteCount = Encoding.UTF8.GetByteCount(type);
59  if (typeByteCount > Util.StackAllocationSizeLimit)
60  {
61  nativeType = Util.Allocate(typeByteCount + 1);
62  }
63  else
64  {
65  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
66  nativeType = nativeTypeStackBytes;
67  }
68 
69  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
70  nativeType[nativeTypeOffset] = 0;
71  }
72  else
73  {
74  nativeType = null;
75  }
76 
77  ImGuiDragDrops flag = 0;
78  ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(nativeType, flag);
79  if (typeByteCount > Util.StackAllocationSizeLimit)
80  {
81  Util.Free(nativeType);
82  }
83 
84  return new ImGuiPayloadPtr(ret);
85  }
86 
93  public static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDrops flag)
94  {
95  byte* nativeType;
96  int typeByteCount = 0;
97  if (type != null)
98  {
99  typeByteCount = Encoding.UTF8.GetByteCount(type);
100  if (typeByteCount > Util.StackAllocationSizeLimit)
101  {
102  nativeType = Util.Allocate(typeByteCount + 1);
103  }
104  else
105  {
106  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
107  nativeType = nativeTypeStackBytes;
108  }
109 
110  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
111  nativeType[nativeTypeOffset] = 0;
112  }
113  else
114  {
115  nativeType = null;
116  }
117 
118  ImGuiPayload* ret = ImGuiNative.igAcceptDragDropPayload(nativeType, flag);
119  if (typeByteCount > Util.StackAllocationSizeLimit)
120  {
121  Util.Free(nativeType);
122  }
123 
124  return new ImGuiPayloadPtr(ret);
125  }
126 
130  public static void AlignTextToFramePadding()
131  {
133  }
134 
141  public static bool ArrowButton(string strId, ImGuiDir dir)
142  {
143  byte* nativeStrId;
144  int strIdByteCount = 0;
145  if (strId != null)
146  {
147  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
148  if (strIdByteCount > Util.StackAllocationSizeLimit)
149  {
150  nativeStrId = Util.Allocate(strIdByteCount + 1);
151  }
152  else
153  {
154  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
155  nativeStrId = nativeStrIdStackBytes;
156  }
157 
158  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
159  nativeStrId[nativeStrIdOffset] = 0;
160  }
161  else
162  {
163  nativeStrId = null;
164  }
165 
166  byte ret = ImGuiNative.igArrowButton(nativeStrId, dir);
167  if (strIdByteCount > Util.StackAllocationSizeLimit)
168  {
169  Util.Free(nativeStrId);
170  }
171 
172  return ret != 0;
173  }
174 
180  public static bool Begin(string name)
181  {
182  byte* nativeName;
183  int nameByteCount = 0;
184  if (name != null)
185  {
186  nameByteCount = Encoding.UTF8.GetByteCount(name);
187  if (nameByteCount > Util.StackAllocationSizeLimit)
188  {
189  nativeName = Util.Allocate(nameByteCount + 1);
190  }
191  else
192  {
193  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
194  nativeName = nativeNameStackBytes;
195  }
196 
197  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
198  nativeName[nativeNameOffset] = 0;
199  }
200  else
201  {
202  nativeName = null;
203  }
204 
205  byte* pOpen = null;
206  ImGuiWindows flag = 0;
207  byte ret = ImGuiNative.igBegin(nativeName, pOpen, flag);
208  if (nameByteCount > Util.StackAllocationSizeLimit)
209  {
210  Util.Free(nativeName);
211  }
212 
213  return ret != 0;
214  }
215 
222  public static bool Begin(string name, ref bool pOpen)
223  {
224  byte* nativeName;
225  int nameByteCount = 0;
226  if (name != null)
227  {
228  nameByteCount = Encoding.UTF8.GetByteCount(name);
229  if (nameByteCount > Util.StackAllocationSizeLimit)
230  {
231  nativeName = Util.Allocate(nameByteCount + 1);
232  }
233  else
234  {
235  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
236  nativeName = nativeNameStackBytes;
237  }
238 
239  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
240  nativeName[nativeNameOffset] = 0;
241  }
242  else
243  {
244  nativeName = null;
245  }
246 
247  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
248  byte* nativePOpen = &nativePOpenVal;
249  ImGuiWindows flag = 0;
250  byte ret = ImGuiNative.igBegin(nativeName, nativePOpen, flag);
251  if (nameByteCount > Util.StackAllocationSizeLimit)
252  {
253  Util.Free(nativeName);
254  }
255 
256  pOpen = nativePOpenVal != 0;
257  return ret != 0;
258  }
259 
267  public static bool Begin(string name, ref bool pOpen, ImGuiWindows flag)
268  {
269  byte* nativeName;
270  int nameByteCount = 0;
271  if (name != null)
272  {
273  nameByteCount = Encoding.UTF8.GetByteCount(name);
274  if (nameByteCount > Util.StackAllocationSizeLimit)
275  {
276  nativeName = Util.Allocate(nameByteCount + 1);
277  }
278  else
279  {
280  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
281  nativeName = nativeNameStackBytes;
282  }
283 
284  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
285  nativeName[nativeNameOffset] = 0;
286  }
287  else
288  {
289  nativeName = null;
290  }
291 
292  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
293  byte* nativePOpen = &nativePOpenVal;
294  byte ret = ImGuiNative.igBegin(nativeName, nativePOpen, flag);
295  if (nameByteCount > Util.StackAllocationSizeLimit)
296  {
297  Util.Free(nativeName);
298  }
299 
300  pOpen = nativePOpenVal != 0;
301  return ret != 0;
302  }
303 
309  public static bool BeginChild(string strId)
310  {
311  byte* nativeStrId;
312  int strIdByteCount = 0;
313  if (strId != null)
314  {
315  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
316  if (strIdByteCount > Util.StackAllocationSizeLimit)
317  {
318  nativeStrId = Util.Allocate(strIdByteCount + 1);
319  }
320  else
321  {
322  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
323  nativeStrId = nativeStrIdStackBytes;
324  }
325 
326  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
327  nativeStrId[nativeStrIdOffset] = 0;
328  }
329  else
330  {
331  nativeStrId = null;
332  }
333 
334  Vector2F size = new Vector2F();
335  byte border = 0;
336  ImGuiWindows flag = 0;
337  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, border, flag);
338  if (strIdByteCount > Util.StackAllocationSizeLimit)
339  {
340  Util.Free(nativeStrId);
341  }
342 
343  return ret != 0;
344  }
345 
352  public static bool BeginChild(string strId, Vector2F size)
353  {
354  byte* nativeStrId;
355  int strIdByteCount = 0;
356  if (strId != null)
357  {
358  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
359  if (strIdByteCount > Util.StackAllocationSizeLimit)
360  {
361  nativeStrId = Util.Allocate(strIdByteCount + 1);
362  }
363  else
364  {
365  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
366  nativeStrId = nativeStrIdStackBytes;
367  }
368 
369  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
370  nativeStrId[nativeStrIdOffset] = 0;
371  }
372  else
373  {
374  nativeStrId = null;
375  }
376 
377  byte border = 0;
378  ImGuiWindows flag = 0;
379  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, border, flag);
380  if (strIdByteCount > Util.StackAllocationSizeLimit)
381  {
382  Util.Free(nativeStrId);
383  }
384 
385  return ret != 0;
386  }
387 
395  public static bool BeginChild(string strId, Vector2F size, bool border)
396  {
397  byte* nativeStrId;
398  int strIdByteCount = 0;
399  if (strId != null)
400  {
401  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
402  if (strIdByteCount > Util.StackAllocationSizeLimit)
403  {
404  nativeStrId = Util.Allocate(strIdByteCount + 1);
405  }
406  else
407  {
408  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
409  nativeStrId = nativeStrIdStackBytes;
410  }
411 
412  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
413  nativeStrId[nativeStrIdOffset] = 0;
414  }
415  else
416  {
417  nativeStrId = null;
418  }
419 
420  byte nativeBorder = border ? (byte) 1 : (byte) 0;
421  ImGuiWindows flag = 0;
422  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, nativeBorder, flag);
423  if (strIdByteCount > Util.StackAllocationSizeLimit)
424  {
425  Util.Free(nativeStrId);
426  }
427 
428  return ret != 0;
429  }
430 
439  public static bool BeginChild(string strId, Vector2F size, bool border, ImGuiWindows flag)
440  {
441  byte* nativeStrId;
442  int strIdByteCount = 0;
443  if (strId != null)
444  {
445  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
446  if (strIdByteCount > Util.StackAllocationSizeLimit)
447  {
448  nativeStrId = Util.Allocate(strIdByteCount + 1);
449  }
450  else
451  {
452  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
453  nativeStrId = nativeStrIdStackBytes;
454  }
455 
456  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
457  nativeStrId[nativeStrIdOffset] = 0;
458  }
459  else
460  {
461  nativeStrId = null;
462  }
463 
464  byte nativeBorder = border ? (byte) 1 : (byte) 0;
465  byte ret = ImGuiNative.igBeginChild_Str(nativeStrId, size, nativeBorder, flag);
466  if (strIdByteCount > Util.StackAllocationSizeLimit)
467  {
468  Util.Free(nativeStrId);
469  }
470 
471  return ret != 0;
472  }
473 
479  public static bool BeginChild(uint id)
480  {
481  Vector2F size = new Vector2F();
482  byte border = 0;
483  ImGuiWindows flag = 0;
484  byte ret = ImGuiNative.igBeginChild_ID(id, size, border, flag);
485  return ret != 0;
486  }
487 
494  public static bool BeginChild(uint id, Vector2F size)
495  {
496  byte border = 0;
497  ImGuiWindows flag = 0;
498  byte ret = ImGuiNative.igBeginChild_ID(id, size, border, flag);
499  return ret != 0;
500  }
501 
509  public static bool BeginChild(uint id, Vector2F size, bool border)
510  {
511  byte nativeBorder = border ? (byte) 1 : (byte) 0;
512  ImGuiWindows flag = 0;
513  byte ret = ImGuiNative.igBeginChild_ID(id, size, nativeBorder, flag);
514  return ret != 0;
515  }
516 
525  public static bool BeginChild(uint id, Vector2F size, bool border, ImGuiWindows flag)
526  {
527  byte nativeBorder = border ? (byte) 1 : (byte) 0;
528  byte ret = ImGuiNative.igBeginChild_ID(id, size, nativeBorder, flag);
529  return ret != 0;
530  }
531 
538  public static bool BeginChildFrame(uint id, Vector2F size)
539  {
540  ImGuiWindows flag = 0;
541  byte ret = ImGuiNative.igBeginChildFrame(id, size, flag);
542  return ret != 0;
543  }
544 
552  public static bool BeginChildFrame(uint id, Vector2F size, ImGuiWindows flag)
553  {
554  byte ret = ImGuiNative.igBeginChildFrame(id, size, flag);
555  return ret != 0;
556  }
557 
564  public static bool BeginCombo(string label, string previewValue)
565  {
566  byte* nativeLabel;
567  int labelByteCount = 0;
568  if (label != null)
569  {
570  labelByteCount = Encoding.UTF8.GetByteCount(label);
571  if (labelByteCount > Util.StackAllocationSizeLimit)
572  {
573  nativeLabel = Util.Allocate(labelByteCount + 1);
574  }
575  else
576  {
577  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
578  nativeLabel = nativeLabelStackBytes;
579  }
580 
581  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
582  nativeLabel[nativeLabelOffset] = 0;
583  }
584  else
585  {
586  nativeLabel = null;
587  }
588 
589  byte* nativePreviewValue;
590  int previewValueByteCount = 0;
591  if (previewValue != null)
592  {
593  previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
594  if (previewValueByteCount > Util.StackAllocationSizeLimit)
595  {
596  nativePreviewValue = Util.Allocate(previewValueByteCount + 1);
597  }
598  else
599  {
600  byte* nativePreviewValueStackBytes = stackalloc byte[previewValueByteCount + 1];
601  nativePreviewValue = nativePreviewValueStackBytes;
602  }
603 
604  int nativePreviewValueOffset = Util.GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
605  nativePreviewValue[nativePreviewValueOffset] = 0;
606  }
607  else
608  {
609  nativePreviewValue = null;
610  }
611 
612  ImGuiCombos flag = 0;
613  byte ret = ImGuiNative.igBeginCombo(nativeLabel, nativePreviewValue, flag);
614  if (labelByteCount > Util.StackAllocationSizeLimit)
615  {
616  Util.Free(nativeLabel);
617  }
618 
619  if (previewValueByteCount > Util.StackAllocationSizeLimit)
620  {
621  Util.Free(nativePreviewValue);
622  }
623 
624  return ret != 0;
625  }
626 
634  public static bool BeginCombo(string label, string previewValue, ImGuiCombos flag)
635  {
636  byte* nativeLabel;
637  int labelByteCount = 0;
638  if (label != null)
639  {
640  labelByteCount = Encoding.UTF8.GetByteCount(label);
641  if (labelByteCount > Util.StackAllocationSizeLimit)
642  {
643  nativeLabel = Util.Allocate(labelByteCount + 1);
644  }
645  else
646  {
647  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
648  nativeLabel = nativeLabelStackBytes;
649  }
650 
651  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
652  nativeLabel[nativeLabelOffset] = 0;
653  }
654  else
655  {
656  nativeLabel = null;
657  }
658 
659  byte* nativePreviewValue;
660  int previewValueByteCount = 0;
661  if (previewValue != null)
662  {
663  previewValueByteCount = Encoding.UTF8.GetByteCount(previewValue);
664  if (previewValueByteCount > Util.StackAllocationSizeLimit)
665  {
666  nativePreviewValue = Util.Allocate(previewValueByteCount + 1);
667  }
668  else
669  {
670  byte* nativePreviewValueStackBytes = stackalloc byte[previewValueByteCount + 1];
671  nativePreviewValue = nativePreviewValueStackBytes;
672  }
673 
674  int nativePreviewValueOffset = Util.GetUtf8(previewValue, nativePreviewValue, previewValueByteCount);
675  nativePreviewValue[nativePreviewValueOffset] = 0;
676  }
677  else
678  {
679  nativePreviewValue = null;
680  }
681 
682  byte ret = ImGuiNative.igBeginCombo(nativeLabel, nativePreviewValue, flag);
683  if (labelByteCount > Util.StackAllocationSizeLimit)
684  {
685  Util.Free(nativeLabel);
686  }
687 
688  if (previewValueByteCount > Util.StackAllocationSizeLimit)
689  {
690  Util.Free(nativePreviewValue);
691  }
692 
693  return ret != 0;
694  }
695 
699  public static void BeginDisabled()
700  {
701  byte disabled = 1;
702  ImGuiNative.igBeginDisabled(disabled);
703  }
704 
709  public static void BeginDisabled(bool disabled)
710  {
711  byte nativeDisabled = disabled ? (byte) 1 : (byte) 0;
712  ImGuiNative.igBeginDisabled(nativeDisabled);
713  }
714 
719  public static bool BeginDragDropSource()
720  {
721  ImGuiDragDrops flag = 0;
722  byte ret = ImGuiNative.igBeginDragDropSource(flag);
723  return ret != 0;
724  }
725 
731  public static bool BeginDragDropSource(ImGuiDragDrops flag)
732  {
733  byte ret = ImGuiNative.igBeginDragDropSource(flag);
734  return ret != 0;
735  }
736 
741  public static bool BeginDragDropTarget()
742  {
743  byte ret = ImGuiNative.igBeginDragDropTarget();
744  return ret != 0;
745  }
746 
750  public static void BeginGroup()
751  {
753  }
754 
760  public static bool BeginListBox(string label)
761  {
762  byte* nativeLabel;
763  int labelByteCount = 0;
764  if (label != null)
765  {
766  labelByteCount = Encoding.UTF8.GetByteCount(label);
767  if (labelByteCount > Util.StackAllocationSizeLimit)
768  {
769  nativeLabel = Util.Allocate(labelByteCount + 1);
770  }
771  else
772  {
773  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
774  nativeLabel = nativeLabelStackBytes;
775  }
776 
777  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
778  nativeLabel[nativeLabelOffset] = 0;
779  }
780  else
781  {
782  nativeLabel = null;
783  }
784 
785  Vector2F size = new Vector2F();
786  byte ret = ImGuiNative.igBeginListBox(nativeLabel, size);
787  if (labelByteCount > Util.StackAllocationSizeLimit)
788  {
789  Util.Free(nativeLabel);
790  }
791 
792  return ret != 0;
793  }
794 
801  public static bool BeginListBox(string label, Vector2F size)
802  {
803  byte* nativeLabel;
804  int labelByteCount = 0;
805  if (label != null)
806  {
807  labelByteCount = Encoding.UTF8.GetByteCount(label);
808  if (labelByteCount > Util.StackAllocationSizeLimit)
809  {
810  nativeLabel = Util.Allocate(labelByteCount + 1);
811  }
812  else
813  {
814  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
815  nativeLabel = nativeLabelStackBytes;
816  }
817 
818  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
819  nativeLabel[nativeLabelOffset] = 0;
820  }
821  else
822  {
823  nativeLabel = null;
824  }
825 
826  byte ret = ImGuiNative.igBeginListBox(nativeLabel, size);
827  if (labelByteCount > Util.StackAllocationSizeLimit)
828  {
829  Util.Free(nativeLabel);
830  }
831 
832  return ret != 0;
833  }
834 
839  public static bool BeginMainMenuBar()
840  {
841  byte ret = ImGuiNative.igBeginMainMenuBar();
842  return ret != 0;
843  }
844 
850  public static bool BeginMenu(string label)
851  {
852  byte* nativeLabel;
853  int labelByteCount = 0;
854  if (label != null)
855  {
856  labelByteCount = Encoding.UTF8.GetByteCount(label);
857  if (labelByteCount > Util.StackAllocationSizeLimit)
858  {
859  nativeLabel = Util.Allocate(labelByteCount + 1);
860  }
861  else
862  {
863  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
864  nativeLabel = nativeLabelStackBytes;
865  }
866 
867  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
868  nativeLabel[nativeLabelOffset] = 0;
869  }
870  else
871  {
872  nativeLabel = null;
873  }
874 
875  byte enabled = 1;
876  byte ret = ImGuiNative.igBeginMenu(nativeLabel, enabled);
877  if (labelByteCount > Util.StackAllocationSizeLimit)
878  {
879  Util.Free(nativeLabel);
880  }
881 
882  return ret != 0;
883  }
884 
891  public static bool BeginMenu(string label, bool enabled)
892  {
893  byte* nativeLabel;
894  int labelByteCount = 0;
895  if (label != null)
896  {
897  labelByteCount = Encoding.UTF8.GetByteCount(label);
898  if (labelByteCount > Util.StackAllocationSizeLimit)
899  {
900  nativeLabel = Util.Allocate(labelByteCount + 1);
901  }
902  else
903  {
904  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
905  nativeLabel = nativeLabelStackBytes;
906  }
907 
908  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
909  nativeLabel[nativeLabelOffset] = 0;
910  }
911  else
912  {
913  nativeLabel = null;
914  }
915 
916  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
917  byte ret = ImGuiNative.igBeginMenu(nativeLabel, nativeEnabled);
918  if (labelByteCount > Util.StackAllocationSizeLimit)
919  {
920  Util.Free(nativeLabel);
921  }
922 
923  return ret != 0;
924  }
925 
930  public static bool BeginMenuBar()
931  {
932  byte ret = ImGuiNative.igBeginMenuBar();
933  return ret != 0;
934  }
935 
941  public static bool BeginPopup(string strId)
942  {
943  byte* nativeStrId;
944  int strIdByteCount = 0;
945  if (strId != null)
946  {
947  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
948  if (strIdByteCount > Util.StackAllocationSizeLimit)
949  {
950  nativeStrId = Util.Allocate(strIdByteCount + 1);
951  }
952  else
953  {
954  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
955  nativeStrId = nativeStrIdStackBytes;
956  }
957 
958  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
959  nativeStrId[nativeStrIdOffset] = 0;
960  }
961  else
962  {
963  nativeStrId = null;
964  }
965 
966  ImGuiWindows flag = 0;
967  byte ret = ImGuiNative.igBeginPopup(nativeStrId, flag);
968  if (strIdByteCount > Util.StackAllocationSizeLimit)
969  {
970  Util.Free(nativeStrId);
971  }
972 
973  return ret != 0;
974  }
975 
982  public static bool BeginPopup(string strId, ImGuiWindows flag)
983  {
984  byte* nativeStrId;
985  int strIdByteCount = 0;
986  if (strId != null)
987  {
988  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
989  if (strIdByteCount > Util.StackAllocationSizeLimit)
990  {
991  nativeStrId = Util.Allocate(strIdByteCount + 1);
992  }
993  else
994  {
995  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
996  nativeStrId = nativeStrIdStackBytes;
997  }
998 
999  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1000  nativeStrId[nativeStrIdOffset] = 0;
1001  }
1002  else
1003  {
1004  nativeStrId = null;
1005  }
1006 
1007  byte ret = ImGuiNative.igBeginPopup(nativeStrId, flag);
1008  if (strIdByteCount > Util.StackAllocationSizeLimit)
1009  {
1010  Util.Free(nativeStrId);
1011  }
1012 
1013  return ret != 0;
1014  }
1015 
1020  public static bool BeginPopupContextItem()
1021  {
1022  byte* nativeStrId = null;
1023  ImGuiPopups popups = (ImGuiPopups) 1;
1024  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popups);
1025  return ret != 0;
1026  }
1027 
1033  public static bool BeginPopupContextItem(string strId)
1034  {
1035  byte* nativeStrId;
1036  int strIdByteCount = 0;
1037  if (strId != null)
1038  {
1039  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1040  if (strIdByteCount > Util.StackAllocationSizeLimit)
1041  {
1042  nativeStrId = Util.Allocate(strIdByteCount + 1);
1043  }
1044  else
1045  {
1046  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1047  nativeStrId = nativeStrIdStackBytes;
1048  }
1049 
1050  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1051  nativeStrId[nativeStrIdOffset] = 0;
1052  }
1053  else
1054  {
1055  nativeStrId = null;
1056  }
1057 
1058  ImGuiPopups popups = (ImGuiPopups) 1;
1059  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popups);
1060  if (strIdByteCount > Util.StackAllocationSizeLimit)
1061  {
1062  Util.Free(nativeStrId);
1063  }
1064 
1065  return ret != 0;
1066  }
1067 
1074  public static bool BeginPopupContextItem(string strId, ImGuiPopups popups)
1075  {
1076  byte* nativeStrId;
1077  int strIdByteCount = 0;
1078  if (strId != null)
1079  {
1080  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1081  if (strIdByteCount > Util.StackAllocationSizeLimit)
1082  {
1083  nativeStrId = Util.Allocate(strIdByteCount + 1);
1084  }
1085  else
1086  {
1087  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1088  nativeStrId = nativeStrIdStackBytes;
1089  }
1090 
1091  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1092  nativeStrId[nativeStrIdOffset] = 0;
1093  }
1094  else
1095  {
1096  nativeStrId = null;
1097  }
1098 
1099  byte ret = ImGuiNative.igBeginPopupContextItem(nativeStrId, popups);
1100  if (strIdByteCount > Util.StackAllocationSizeLimit)
1101  {
1102  Util.Free(nativeStrId);
1103  }
1104 
1105  return ret != 0;
1106  }
1107 
1112  public static bool BeginPopupContextVoid()
1113  {
1114  byte* nativeStrId = null;
1115  ImGuiPopups popups = (ImGuiPopups) 1;
1116  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popups);
1117  return ret != 0;
1118  }
1119 
1125  public static bool BeginPopupContextVoid(string strId)
1126  {
1127  byte* nativeStrId;
1128  int strIdByteCount = 0;
1129  if (strId != null)
1130  {
1131  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1132  if (strIdByteCount > Util.StackAllocationSizeLimit)
1133  {
1134  nativeStrId = Util.Allocate(strIdByteCount + 1);
1135  }
1136  else
1137  {
1138  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1139  nativeStrId = nativeStrIdStackBytes;
1140  }
1141 
1142  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1143  nativeStrId[nativeStrIdOffset] = 0;
1144  }
1145  else
1146  {
1147  nativeStrId = null;
1148  }
1149 
1150  ImGuiPopups popups = (ImGuiPopups) 1;
1151  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popups);
1152  if (strIdByteCount > Util.StackAllocationSizeLimit)
1153  {
1154  Util.Free(nativeStrId);
1155  }
1156 
1157  return ret != 0;
1158  }
1159 
1166  public static bool BeginPopupContextVoid(string strId, ImGuiPopups popups)
1167  {
1168  byte* nativeStrId;
1169  int strIdByteCount = 0;
1170  if (strId != null)
1171  {
1172  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1173  if (strIdByteCount > Util.StackAllocationSizeLimit)
1174  {
1175  nativeStrId = Util.Allocate(strIdByteCount + 1);
1176  }
1177  else
1178  {
1179  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1180  nativeStrId = nativeStrIdStackBytes;
1181  }
1182 
1183  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1184  nativeStrId[nativeStrIdOffset] = 0;
1185  }
1186  else
1187  {
1188  nativeStrId = null;
1189  }
1190 
1191  byte ret = ImGuiNative.igBeginPopupContextVoid(nativeStrId, popups);
1192  if (strIdByteCount > Util.StackAllocationSizeLimit)
1193  {
1194  Util.Free(nativeStrId);
1195  }
1196 
1197  return ret != 0;
1198  }
1199 
1204  public static bool BeginPopupContextWindow()
1205  {
1206  byte* nativeStrId = null;
1207  ImGuiPopups popups = (ImGuiPopups) 1;
1208  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popups);
1209  return ret != 0;
1210  }
1211 
1217  public static bool BeginPopupContextWindow(string strId)
1218  {
1219  byte* nativeStrId;
1220  int strIdByteCount = 0;
1221  if (strId != null)
1222  {
1223  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1224  if (strIdByteCount > Util.StackAllocationSizeLimit)
1225  {
1226  nativeStrId = Util.Allocate(strIdByteCount + 1);
1227  }
1228  else
1229  {
1230  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1231  nativeStrId = nativeStrIdStackBytes;
1232  }
1233 
1234  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1235  nativeStrId[nativeStrIdOffset] = 0;
1236  }
1237  else
1238  {
1239  nativeStrId = null;
1240  }
1241 
1242  ImGuiPopups popups = (ImGuiPopups) 1;
1243  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popups);
1244  if (strIdByteCount > Util.StackAllocationSizeLimit)
1245  {
1246  Util.Free(nativeStrId);
1247  }
1248 
1249  return ret != 0;
1250  }
1251 
1258  public static bool BeginPopupContextWindow(string strId, ImGuiPopups popups)
1259  {
1260  byte* nativeStrId;
1261  int strIdByteCount = 0;
1262  if (strId != null)
1263  {
1264  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1265  if (strIdByteCount > Util.StackAllocationSizeLimit)
1266  {
1267  nativeStrId = Util.Allocate(strIdByteCount + 1);
1268  }
1269  else
1270  {
1271  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1272  nativeStrId = nativeStrIdStackBytes;
1273  }
1274 
1275  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1276  nativeStrId[nativeStrIdOffset] = 0;
1277  }
1278  else
1279  {
1280  nativeStrId = null;
1281  }
1282 
1283  byte ret = ImGuiNative.igBeginPopupContextWindow(nativeStrId, popups);
1284  if (strIdByteCount > Util.StackAllocationSizeLimit)
1285  {
1286  Util.Free(nativeStrId);
1287  }
1288 
1289  return ret != 0;
1290  }
1291 
1297  public static bool BeginPopupModal(string name)
1298  {
1299  byte* nativeName;
1300  int nameByteCount = 0;
1301  if (name != null)
1302  {
1303  nameByteCount = Encoding.UTF8.GetByteCount(name);
1304  if (nameByteCount > Util.StackAllocationSizeLimit)
1305  {
1306  nativeName = Util.Allocate(nameByteCount + 1);
1307  }
1308  else
1309  {
1310  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1311  nativeName = nativeNameStackBytes;
1312  }
1313 
1314  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1315  nativeName[nativeNameOffset] = 0;
1316  }
1317  else
1318  {
1319  nativeName = null;
1320  }
1321 
1322  byte* pOpen = null;
1323  ImGuiWindows flag = 0;
1324  byte ret = ImGuiNative.igBeginPopupModal(nativeName, pOpen, flag);
1325  if (nameByteCount > Util.StackAllocationSizeLimit)
1326  {
1327  Util.Free(nativeName);
1328  }
1329 
1330  return ret != 0;
1331  }
1332 
1339  public static bool BeginPopupModal(string name, ref bool pOpen)
1340  {
1341  byte* nativeName;
1342  int nameByteCount = 0;
1343  if (name != null)
1344  {
1345  nameByteCount = Encoding.UTF8.GetByteCount(name);
1346  if (nameByteCount > Util.StackAllocationSizeLimit)
1347  {
1348  nativeName = Util.Allocate(nameByteCount + 1);
1349  }
1350  else
1351  {
1352  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1353  nativeName = nativeNameStackBytes;
1354  }
1355 
1356  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1357  nativeName[nativeNameOffset] = 0;
1358  }
1359  else
1360  {
1361  nativeName = null;
1362  }
1363 
1364  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1365  byte* nativePOpen = &nativePOpenVal;
1366  ImGuiWindows flag = 0;
1367  byte ret = ImGuiNative.igBeginPopupModal(nativeName, nativePOpen, flag);
1368  if (nameByteCount > Util.StackAllocationSizeLimit)
1369  {
1370  Util.Free(nativeName);
1371  }
1372 
1373  pOpen = nativePOpenVal != 0;
1374  return ret != 0;
1375  }
1376 
1384  public static bool BeginPopupModal(string name, ref bool pOpen, ImGuiWindows flag)
1385  {
1386  byte* nativeName;
1387  int nameByteCount = 0;
1388  if (name != null)
1389  {
1390  nameByteCount = Encoding.UTF8.GetByteCount(name);
1391  if (nameByteCount > Util.StackAllocationSizeLimit)
1392  {
1393  nativeName = Util.Allocate(nameByteCount + 1);
1394  }
1395  else
1396  {
1397  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
1398  nativeName = nativeNameStackBytes;
1399  }
1400 
1401  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
1402  nativeName[nativeNameOffset] = 0;
1403  }
1404  else
1405  {
1406  nativeName = null;
1407  }
1408 
1409  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1410  byte* nativePOpen = &nativePOpenVal;
1411  byte ret = ImGuiNative.igBeginPopupModal(nativeName, nativePOpen, flag);
1412  if (nameByteCount > Util.StackAllocationSizeLimit)
1413  {
1414  Util.Free(nativeName);
1415  }
1416 
1417  pOpen = nativePOpenVal != 0;
1418  return ret != 0;
1419  }
1420 
1426  public static bool BeginTabBar(string strId)
1427  {
1428  byte* nativeStrId;
1429  int strIdByteCount = 0;
1430  if (strId != null)
1431  {
1432  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1433  if (strIdByteCount > Util.StackAllocationSizeLimit)
1434  {
1435  nativeStrId = Util.Allocate(strIdByteCount + 1);
1436  }
1437  else
1438  {
1439  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1440  nativeStrId = nativeStrIdStackBytes;
1441  }
1442 
1443  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1444  nativeStrId[nativeStrIdOffset] = 0;
1445  }
1446  else
1447  {
1448  nativeStrId = null;
1449  }
1450 
1451  ImGuiTabBars flag = 0;
1452  byte ret = ImGuiNative.igBeginTabBar(nativeStrId, flag);
1453  if (strIdByteCount > Util.StackAllocationSizeLimit)
1454  {
1455  Util.Free(nativeStrId);
1456  }
1457 
1458  return ret != 0;
1459  }
1460 
1467  public static bool BeginTabBar(string strId, ImGuiTabBars flag)
1468  {
1469  byte* nativeStrId;
1470  int strIdByteCount = 0;
1471  if (strId != null)
1472  {
1473  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1474  if (strIdByteCount > Util.StackAllocationSizeLimit)
1475  {
1476  nativeStrId = Util.Allocate(strIdByteCount + 1);
1477  }
1478  else
1479  {
1480  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1481  nativeStrId = nativeStrIdStackBytes;
1482  }
1483 
1484  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1485  nativeStrId[nativeStrIdOffset] = 0;
1486  }
1487  else
1488  {
1489  nativeStrId = null;
1490  }
1491 
1492  byte ret = ImGuiNative.igBeginTabBar(nativeStrId, flag);
1493  if (strIdByteCount > Util.StackAllocationSizeLimit)
1494  {
1495  Util.Free(nativeStrId);
1496  }
1497 
1498  return ret != 0;
1499  }
1500 
1506  public static bool BeginTabItem(string label)
1507  {
1508  byte* nativeLabel;
1509  int labelByteCount = 0;
1510  if (label != null)
1511  {
1512  labelByteCount = Encoding.UTF8.GetByteCount(label);
1513  if (labelByteCount > Util.StackAllocationSizeLimit)
1514  {
1515  nativeLabel = Util.Allocate(labelByteCount + 1);
1516  }
1517  else
1518  {
1519  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1520  nativeLabel = nativeLabelStackBytes;
1521  }
1522 
1523  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1524  nativeLabel[nativeLabelOffset] = 0;
1525  }
1526  else
1527  {
1528  nativeLabel = null;
1529  }
1530 
1531  byte* pOpen = null;
1532  ImGuiTabItems flag = 0;
1533  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, pOpen, flag);
1534  if (labelByteCount > Util.StackAllocationSizeLimit)
1535  {
1536  Util.Free(nativeLabel);
1537  }
1538 
1539  return ret != 0;
1540  }
1541 
1548  public static bool BeginTabItem(string label, ref bool pOpen)
1549  {
1550  byte* nativeLabel;
1551  int labelByteCount = 0;
1552  if (label != null)
1553  {
1554  labelByteCount = Encoding.UTF8.GetByteCount(label);
1555  if (labelByteCount > Util.StackAllocationSizeLimit)
1556  {
1557  nativeLabel = Util.Allocate(labelByteCount + 1);
1558  }
1559  else
1560  {
1561  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1562  nativeLabel = nativeLabelStackBytes;
1563  }
1564 
1565  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1566  nativeLabel[nativeLabelOffset] = 0;
1567  }
1568  else
1569  {
1570  nativeLabel = null;
1571  }
1572 
1573  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1574  byte* nativePOpen = &nativePOpenVal;
1575  ImGuiTabItems flag = 0;
1576  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, nativePOpen, flag);
1577  if (labelByteCount > Util.StackAllocationSizeLimit)
1578  {
1579  Util.Free(nativeLabel);
1580  }
1581 
1582  pOpen = nativePOpenVal != 0;
1583  return ret != 0;
1584  }
1585 
1593  public static bool BeginTabItem(string label, ref bool pOpen, ImGuiTabItems flag)
1594  {
1595  byte* nativeLabel;
1596  int labelByteCount = 0;
1597  if (label != null)
1598  {
1599  labelByteCount = Encoding.UTF8.GetByteCount(label);
1600  if (labelByteCount > Util.StackAllocationSizeLimit)
1601  {
1602  nativeLabel = Util.Allocate(labelByteCount + 1);
1603  }
1604  else
1605  {
1606  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1607  nativeLabel = nativeLabelStackBytes;
1608  }
1609 
1610  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1611  nativeLabel[nativeLabelOffset] = 0;
1612  }
1613  else
1614  {
1615  nativeLabel = null;
1616  }
1617 
1618  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
1619  byte* nativePOpen = &nativePOpenVal;
1620  byte ret = ImGuiNative.igBeginTabItem(nativeLabel, nativePOpen, flag);
1621  if (labelByteCount > Util.StackAllocationSizeLimit)
1622  {
1623  Util.Free(nativeLabel);
1624  }
1625 
1626  pOpen = nativePOpenVal != 0;
1627  return ret != 0;
1628  }
1629 
1636  public static bool BeginTable(string strId, int column)
1637  {
1638  byte* nativeStrId;
1639  int strIdByteCount = 0;
1640  if (strId != null)
1641  {
1642  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1643  if (strIdByteCount > Util.StackAllocationSizeLimit)
1644  {
1645  nativeStrId = Util.Allocate(strIdByteCount + 1);
1646  }
1647  else
1648  {
1649  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1650  nativeStrId = nativeStrIdStackBytes;
1651  }
1652 
1653  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1654  nativeStrId[nativeStrIdOffset] = 0;
1655  }
1656  else
1657  {
1658  nativeStrId = null;
1659  }
1660 
1661  ImGuiTables flag = 0;
1662  Vector2F outerSize = new Vector2F();
1663  float innerWidth = 0.0f;
1664  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flag, outerSize, innerWidth);
1665  if (strIdByteCount > Util.StackAllocationSizeLimit)
1666  {
1667  Util.Free(nativeStrId);
1668  }
1669 
1670  return ret != 0;
1671  }
1672 
1680  public static bool BeginTable(string strId, int column, ImGuiTables flag)
1681  {
1682  byte* nativeStrId;
1683  int strIdByteCount = 0;
1684  if (strId != null)
1685  {
1686  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1687  if (strIdByteCount > Util.StackAllocationSizeLimit)
1688  {
1689  nativeStrId = Util.Allocate(strIdByteCount + 1);
1690  }
1691  else
1692  {
1693  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1694  nativeStrId = nativeStrIdStackBytes;
1695  }
1696 
1697  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1698  nativeStrId[nativeStrIdOffset] = 0;
1699  }
1700  else
1701  {
1702  nativeStrId = null;
1703  }
1704 
1705  Vector2F outerSize = new Vector2F();
1706  float innerWidth = 0.0f;
1707  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flag, outerSize, innerWidth);
1708  if (strIdByteCount > Util.StackAllocationSizeLimit)
1709  {
1710  Util.Free(nativeStrId);
1711  }
1712 
1713  return ret != 0;
1714  }
1715 
1724  public static bool BeginTable(string strId, int column, ImGuiTables flag, Vector2F outerSize)
1725  {
1726  byte* nativeStrId;
1727  int strIdByteCount = 0;
1728  if (strId != null)
1729  {
1730  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1731  if (strIdByteCount > Util.StackAllocationSizeLimit)
1732  {
1733  nativeStrId = Util.Allocate(strIdByteCount + 1);
1734  }
1735  else
1736  {
1737  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1738  nativeStrId = nativeStrIdStackBytes;
1739  }
1740 
1741  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1742  nativeStrId[nativeStrIdOffset] = 0;
1743  }
1744  else
1745  {
1746  nativeStrId = null;
1747  }
1748 
1749  float innerWidth = 0.0f;
1750  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flag, outerSize, innerWidth);
1751  if (strIdByteCount > Util.StackAllocationSizeLimit)
1752  {
1753  Util.Free(nativeStrId);
1754  }
1755 
1756  return ret != 0;
1757  }
1758 
1768  public static bool BeginTable(string strId, int column, ImGuiTables flag, Vector2F outerSize, float innerWidth)
1769  {
1770  byte* nativeStrId;
1771  int strIdByteCount = 0;
1772  if (strId != null)
1773  {
1774  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
1775  if (strIdByteCount > Util.StackAllocationSizeLimit)
1776  {
1777  nativeStrId = Util.Allocate(strIdByteCount + 1);
1778  }
1779  else
1780  {
1781  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
1782  nativeStrId = nativeStrIdStackBytes;
1783  }
1784 
1785  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
1786  nativeStrId[nativeStrIdOffset] = 0;
1787  }
1788  else
1789  {
1790  nativeStrId = null;
1791  }
1792 
1793  byte ret = ImGuiNative.igBeginTable(nativeStrId, column, flag, outerSize, innerWidth);
1794  if (strIdByteCount > Util.StackAllocationSizeLimit)
1795  {
1796  Util.Free(nativeStrId);
1797  }
1798 
1799  return ret != 0;
1800  }
1801 
1806  public static bool BeginTooltip()
1807  {
1808  byte ret = ImGuiNative.igBeginTooltip();
1809  return ret != 0;
1810  }
1811 
1815  public static void Bullet()
1816  {
1818  }
1819 
1824  public static void BulletText(string fmt)
1825  {
1826  byte* nativeFmt;
1827  int fmtByteCount = 0;
1828  if (fmt != null)
1829  {
1830  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
1831  if (fmtByteCount > Util.StackAllocationSizeLimit)
1832  {
1833  nativeFmt = Util.Allocate(fmtByteCount + 1);
1834  }
1835  else
1836  {
1837  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
1838  nativeFmt = nativeFmtStackBytes;
1839  }
1840 
1841  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
1842  nativeFmt[nativeFmtOffset] = 0;
1843  }
1844  else
1845  {
1846  nativeFmt = null;
1847  }
1848 
1849  ImGuiNative.igBulletText(nativeFmt);
1850  if (fmtByteCount > Util.StackAllocationSizeLimit)
1851  {
1852  Util.Free(nativeFmt);
1853  }
1854  }
1855 
1861  public static bool Button(string label)
1862  {
1863  byte* nativeLabel;
1864  int labelByteCount = 0;
1865  if (label != null)
1866  {
1867  labelByteCount = Encoding.UTF8.GetByteCount(label);
1868  if (labelByteCount > Util.StackAllocationSizeLimit)
1869  {
1870  nativeLabel = Util.Allocate(labelByteCount + 1);
1871  }
1872  else
1873  {
1874  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1875  nativeLabel = nativeLabelStackBytes;
1876  }
1877 
1878  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1879  nativeLabel[nativeLabelOffset] = 0;
1880  }
1881  else
1882  {
1883  nativeLabel = null;
1884  }
1885 
1886  Vector2F size = new Vector2F();
1887  byte ret = ImGuiNative.igButton(nativeLabel, size);
1888  if (labelByteCount > Util.StackAllocationSizeLimit)
1889  {
1890  Util.Free(nativeLabel);
1891  }
1892 
1893  return ret != 0;
1894  }
1895 
1902  public static bool Button(string label, Vector2F size)
1903  {
1904  byte* nativeLabel;
1905  int labelByteCount = 0;
1906  if (label != null)
1907  {
1908  labelByteCount = Encoding.UTF8.GetByteCount(label);
1909  if (labelByteCount > Util.StackAllocationSizeLimit)
1910  {
1911  nativeLabel = Util.Allocate(labelByteCount + 1);
1912  }
1913  else
1914  {
1915  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1916  nativeLabel = nativeLabelStackBytes;
1917  }
1918 
1919  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1920  nativeLabel[nativeLabelOffset] = 0;
1921  }
1922  else
1923  {
1924  nativeLabel = null;
1925  }
1926 
1927  byte ret = ImGuiNative.igButton(nativeLabel, size);
1928  if (labelByteCount > Util.StackAllocationSizeLimit)
1929  {
1930  Util.Free(nativeLabel);
1931  }
1932 
1933  return ret != 0;
1934  }
1935 
1940  public static float CalcItemWidth()
1941  {
1942  float ret = ImGuiNative.igCalcItemWidth();
1943  return ret;
1944  }
1945 
1952  public static bool Checkbox(string label, ref bool v)
1953  {
1954  byte* nativeLabel;
1955  int labelByteCount = 0;
1956  if (label != null)
1957  {
1958  labelByteCount = Encoding.UTF8.GetByteCount(label);
1959  if (labelByteCount > Util.StackAllocationSizeLimit)
1960  {
1961  nativeLabel = Util.Allocate(labelByteCount + 1);
1962  }
1963  else
1964  {
1965  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
1966  nativeLabel = nativeLabelStackBytes;
1967  }
1968 
1969  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
1970  nativeLabel[nativeLabelOffset] = 0;
1971  }
1972  else
1973  {
1974  nativeLabel = null;
1975  }
1976 
1977  byte nativeVVal = v ? (byte) 1 : (byte) 0;
1978  byte* nativeV = &nativeVVal;
1979  byte ret = ImGuiNative.igCheckbox(nativeLabel, nativeV);
1980  if (labelByteCount > Util.StackAllocationSizeLimit)
1981  {
1982  Util.Free(nativeLabel);
1983  }
1984 
1985  v = nativeVVal != 0;
1986  return ret != 0;
1987  }
1988 
1996  public static bool CheckboxFlags(string label, ref int flags, int flagsValue)
1997  {
1998  byte* nativeLabel;
1999  int labelByteCount = 0;
2000  if (label != null)
2001  {
2002  labelByteCount = Encoding.UTF8.GetByteCount(label);
2003  if (labelByteCount > Util.StackAllocationSizeLimit)
2004  {
2005  nativeLabel = Util.Allocate(labelByteCount + 1);
2006  }
2007  else
2008  {
2009  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2010  nativeLabel = nativeLabelStackBytes;
2011  }
2012 
2013  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2014  nativeLabel[nativeLabelOffset] = 0;
2015  }
2016  else
2017  {
2018  nativeLabel = null;
2019  }
2020 
2021  fixed (int* nativeFlags = &flags)
2022  {
2023  byte ret = ImGuiNative.igCheckboxFlags_IntPtr(nativeLabel, nativeFlags, flagsValue);
2024  if (labelByteCount > Util.StackAllocationSizeLimit)
2025  {
2026  Util.Free(nativeLabel);
2027  }
2028 
2029  return ret != 0;
2030  }
2031  }
2032 
2040  public static bool CheckboxFlags(string label, ref uint flags, uint flagsValue)
2041  {
2042  byte* nativeLabel;
2043  int labelByteCount = 0;
2044  if (label != null)
2045  {
2046  labelByteCount = Encoding.UTF8.GetByteCount(label);
2047  if (labelByteCount > Util.StackAllocationSizeLimit)
2048  {
2049  nativeLabel = Util.Allocate(labelByteCount + 1);
2050  }
2051  else
2052  {
2053  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2054  nativeLabel = nativeLabelStackBytes;
2055  }
2056 
2057  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2058  nativeLabel[nativeLabelOffset] = 0;
2059  }
2060  else
2061  {
2062  nativeLabel = null;
2063  }
2064 
2065  fixed (uint* nativeFlags = &flags)
2066  {
2067  byte ret = ImGuiNative.igCheckboxFlags_UintPtr(nativeLabel, nativeFlags, flagsValue);
2068  if (labelByteCount > Util.StackAllocationSizeLimit)
2069  {
2070  Util.Free(nativeLabel);
2071  }
2072 
2073  return ret != 0;
2074  }
2075  }
2076 
2080  public static void CloseCurrentPopup()
2081  {
2083  }
2084 
2090  public static bool CollapsingHeader(string label)
2091  {
2092  byte* nativeLabel;
2093  int labelByteCount = 0;
2094  if (label != null)
2095  {
2096  labelByteCount = Encoding.UTF8.GetByteCount(label);
2097  if (labelByteCount > Util.StackAllocationSizeLimit)
2098  {
2099  nativeLabel = Util.Allocate(labelByteCount + 1);
2100  }
2101  else
2102  {
2103  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2104  nativeLabel = nativeLabelStackBytes;
2105  }
2106 
2107  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2108  nativeLabel[nativeLabelOffset] = 0;
2109  }
2110  else
2111  {
2112  nativeLabel = null;
2113  }
2114 
2115  ImGuiTreeNodes flag = 0;
2116  byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(nativeLabel, flag);
2117  if (labelByteCount > Util.StackAllocationSizeLimit)
2118  {
2119  Util.Free(nativeLabel);
2120  }
2121 
2122  return ret != 0;
2123  }
2124 
2131  public static bool CollapsingHeader(string label, ImGuiTreeNodes flag)
2132  {
2133  byte* nativeLabel;
2134  int labelByteCount = 0;
2135  if (label != null)
2136  {
2137  labelByteCount = Encoding.UTF8.GetByteCount(label);
2138  if (labelByteCount > Util.StackAllocationSizeLimit)
2139  {
2140  nativeLabel = Util.Allocate(labelByteCount + 1);
2141  }
2142  else
2143  {
2144  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2145  nativeLabel = nativeLabelStackBytes;
2146  }
2147 
2148  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2149  nativeLabel[nativeLabelOffset] = 0;
2150  }
2151  else
2152  {
2153  nativeLabel = null;
2154  }
2155 
2156  byte ret = ImGuiNative.igCollapsingHeader_TreeNodeFlags(nativeLabel, flag);
2157  if (labelByteCount > Util.StackAllocationSizeLimit)
2158  {
2159  Util.Free(nativeLabel);
2160  }
2161 
2162  return ret != 0;
2163  }
2164 
2171  public static bool CollapsingHeader(string label, ref bool pVisible)
2172  {
2173  byte* nativeLabel;
2174  int labelByteCount = 0;
2175  if (label != null)
2176  {
2177  labelByteCount = Encoding.UTF8.GetByteCount(label);
2178  if (labelByteCount > Util.StackAllocationSizeLimit)
2179  {
2180  nativeLabel = Util.Allocate(labelByteCount + 1);
2181  }
2182  else
2183  {
2184  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2185  nativeLabel = nativeLabelStackBytes;
2186  }
2187 
2188  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2189  nativeLabel[nativeLabelOffset] = 0;
2190  }
2191  else
2192  {
2193  nativeLabel = null;
2194  }
2195 
2196  byte nativePVisibleVal = pVisible ? (byte) 1 : (byte) 0;
2197  byte* nativePVisible = &nativePVisibleVal;
2198  ImGuiTreeNodes flag = 0;
2199  byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(nativeLabel, nativePVisible, flag);
2200  if (labelByteCount > Util.StackAllocationSizeLimit)
2201  {
2202  Util.Free(nativeLabel);
2203  }
2204 
2205  pVisible = nativePVisibleVal != 0;
2206  return ret != 0;
2207  }
2208 
2216  public static bool CollapsingHeader(string label, ref bool pVisible, ImGuiTreeNodes flag)
2217  {
2218  byte* nativeLabel;
2219  int labelByteCount = 0;
2220  if (label != null)
2221  {
2222  labelByteCount = Encoding.UTF8.GetByteCount(label);
2223  if (labelByteCount > Util.StackAllocationSizeLimit)
2224  {
2225  nativeLabel = Util.Allocate(labelByteCount + 1);
2226  }
2227  else
2228  {
2229  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2230  nativeLabel = nativeLabelStackBytes;
2231  }
2232 
2233  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2234  nativeLabel[nativeLabelOffset] = 0;
2235  }
2236  else
2237  {
2238  nativeLabel = null;
2239  }
2240 
2241  byte nativePVisibleVal = pVisible ? (byte) 1 : (byte) 0;
2242  byte* nativePVisible = &nativePVisibleVal;
2243  byte ret = ImGuiNative.igCollapsingHeader_BoolPtr(nativeLabel, nativePVisible, flag);
2244  if (labelByteCount > Util.StackAllocationSizeLimit)
2245  {
2246  Util.Free(nativeLabel);
2247  }
2248 
2249  pVisible = nativePVisibleVal != 0;
2250  return ret != 0;
2251  }
2252 
2259  public static bool ColorButton(string descId, Vector4F col)
2260  {
2261  byte* nativeDescId;
2262  int descIdByteCount = 0;
2263  if (descId != null)
2264  {
2265  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2266  if (descIdByteCount > Util.StackAllocationSizeLimit)
2267  {
2268  nativeDescId = Util.Allocate(descIdByteCount + 1);
2269  }
2270  else
2271  {
2272  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2273  nativeDescId = nativeDescIdStackBytes;
2274  }
2275 
2276  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2277  nativeDescId[nativeDescIdOffset] = 0;
2278  }
2279  else
2280  {
2281  nativeDescId = null;
2282  }
2283 
2284  ImGuiColorEdits flag = 0;
2285  Vector2F size = new Vector2F();
2286  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flag, size);
2287  if (descIdByteCount > Util.StackAllocationSizeLimit)
2288  {
2289  Util.Free(nativeDescId);
2290  }
2291 
2292  return ret != 0;
2293  }
2294 
2302  public static bool ColorButton(string descId, Vector4F col, ImGuiColorEdits flag)
2303  {
2304  byte* nativeDescId;
2305  int descIdByteCount = 0;
2306  if (descId != null)
2307  {
2308  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2309  if (descIdByteCount > Util.StackAllocationSizeLimit)
2310  {
2311  nativeDescId = Util.Allocate(descIdByteCount + 1);
2312  }
2313  else
2314  {
2315  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2316  nativeDescId = nativeDescIdStackBytes;
2317  }
2318 
2319  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2320  nativeDescId[nativeDescIdOffset] = 0;
2321  }
2322  else
2323  {
2324  nativeDescId = null;
2325  }
2326 
2327  Vector2F size = new Vector2F();
2328  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flag, size);
2329  if (descIdByteCount > Util.StackAllocationSizeLimit)
2330  {
2331  Util.Free(nativeDescId);
2332  }
2333 
2334  return ret != 0;
2335  }
2336 
2345  public static bool ColorButton(string descId, Vector4F col, ImGuiColorEdits flag, Vector2F size)
2346  {
2347  byte* nativeDescId;
2348  int descIdByteCount = 0;
2349  if (descId != null)
2350  {
2351  descIdByteCount = Encoding.UTF8.GetByteCount(descId);
2352  if (descIdByteCount > Util.StackAllocationSizeLimit)
2353  {
2354  nativeDescId = Util.Allocate(descIdByteCount + 1);
2355  }
2356  else
2357  {
2358  byte* nativeDescIdStackBytes = stackalloc byte[descIdByteCount + 1];
2359  nativeDescId = nativeDescIdStackBytes;
2360  }
2361 
2362  int nativeDescIdOffset = Util.GetUtf8(descId, nativeDescId, descIdByteCount);
2363  nativeDescId[nativeDescIdOffset] = 0;
2364  }
2365  else
2366  {
2367  nativeDescId = null;
2368  }
2369 
2370  byte ret = ImGuiNative.igColorButton(nativeDescId, col, flag, size);
2371  if (descIdByteCount > Util.StackAllocationSizeLimit)
2372  {
2373  Util.Free(nativeDescId);
2374  }
2375 
2376  return ret != 0;
2377  }
2378 
2383  public static uint ColorConvertFloat4ToU32(Vector4F @in)
2384  {
2385  uint ret = ImGuiNative.igColorConvertFloat4ToU32(@in);
2386  return ret;
2387  }
2388 
2398  public static void ColorConvertHsVtoRgb(float h, float s, float v, out float outR, out float outG, out float outB)
2399  {
2400  fixed (float* nativeOutR = &outR)
2401  {
2402  fixed (float* nativeOutG = &outG)
2403  {
2404  fixed (float* nativeOutB = &outB)
2405  {
2406  ImGuiNative.igColorConvertHSVtoRGB(h, s, v, nativeOutR, nativeOutG, nativeOutB);
2407  }
2408  }
2409  }
2410  }
2411 
2421  public static void ColorConvertRgBtoHsv(float r, float g, float b, out float outH, out float outS, out float outV)
2422  {
2423  fixed (float* nativeOutH = &outH)
2424  {
2425  fixed (float* nativeOutS = &outS)
2426  {
2427  fixed (float* nativeOutV = &outV)
2428  {
2429  ImGuiNative.igColorConvertRGBtoHSV(r, g, b, nativeOutH, nativeOutS, nativeOutV);
2430  }
2431  }
2432  }
2433  }
2434 
2440  public static Vector4F ColorConvertU32ToFloat4(uint @in)
2441  {
2442  Vector4F retval;
2443  ImGuiNative.igColorConvertU32ToFloat4(&retval, @in);
2444  return retval;
2445  }
2446 
2453  public static bool ColorEdit3(string label, ref Vector3F col)
2454  {
2455  byte* nativeLabel;
2456  int labelByteCount = 0;
2457  if (label != null)
2458  {
2459  labelByteCount = Encoding.UTF8.GetByteCount(label);
2460  if (labelByteCount > Util.StackAllocationSizeLimit)
2461  {
2462  nativeLabel = Util.Allocate(labelByteCount + 1);
2463  }
2464  else
2465  {
2466  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2467  nativeLabel = nativeLabelStackBytes;
2468  }
2469 
2470  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2471  nativeLabel[nativeLabelOffset] = 0;
2472  }
2473  else
2474  {
2475  nativeLabel = null;
2476  }
2477 
2478  ImGuiColorEdits flag = 0;
2479  fixed (Vector3F* nativeCol = &col)
2480  {
2481  byte ret = ImGuiNative.igColorEdit3(nativeLabel, nativeCol, flag);
2482  if (labelByteCount > Util.StackAllocationSizeLimit)
2483  {
2484  Util.Free(nativeLabel);
2485  }
2486 
2487  return ret != 0;
2488  }
2489  }
2490 
2498  public static bool ColorEdit3(string label, ref Vector3F col, ImGuiColorEdits flag)
2499  {
2500  byte* nativeLabel;
2501  int labelByteCount = 0;
2502  if (label != null)
2503  {
2504  labelByteCount = Encoding.UTF8.GetByteCount(label);
2505  if (labelByteCount > Util.StackAllocationSizeLimit)
2506  {
2507  nativeLabel = Util.Allocate(labelByteCount + 1);
2508  }
2509  else
2510  {
2511  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2512  nativeLabel = nativeLabelStackBytes;
2513  }
2514 
2515  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2516  nativeLabel[nativeLabelOffset] = 0;
2517  }
2518  else
2519  {
2520  nativeLabel = null;
2521  }
2522 
2523  fixed (Vector3F* nativeCol = &col)
2524  {
2525  byte ret = ImGuiNative.igColorEdit3(nativeLabel, nativeCol, flag);
2526  if (labelByteCount > Util.StackAllocationSizeLimit)
2527  {
2528  Util.Free(nativeLabel);
2529  }
2530 
2531  return ret != 0;
2532  }
2533  }
2534 
2541  public static bool ColorEdit4(string label, ref Vector4F col)
2542  {
2543  byte* nativeLabel;
2544  int labelByteCount = 0;
2545  if (label != null)
2546  {
2547  labelByteCount = Encoding.UTF8.GetByteCount(label);
2548  if (labelByteCount > Util.StackAllocationSizeLimit)
2549  {
2550  nativeLabel = Util.Allocate(labelByteCount + 1);
2551  }
2552  else
2553  {
2554  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2555  nativeLabel = nativeLabelStackBytes;
2556  }
2557 
2558  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2559  nativeLabel[nativeLabelOffset] = 0;
2560  }
2561  else
2562  {
2563  nativeLabel = null;
2564  }
2565 
2566  ImGuiColorEdits flag = 0;
2567  fixed (Vector4F* nativeCol = &col)
2568  {
2569  byte ret = ImGuiNative.igColorEdit4(nativeLabel, nativeCol, flag);
2570  if (labelByteCount > Util.StackAllocationSizeLimit)
2571  {
2572  Util.Free(nativeLabel);
2573  }
2574 
2575  return ret != 0;
2576  }
2577  }
2578 
2586  public static bool ColorEdit4(string label, ref Vector4F col, ImGuiColorEdits flag)
2587  {
2588  byte* nativeLabel;
2589  int labelByteCount = 0;
2590  if (label != null)
2591  {
2592  labelByteCount = Encoding.UTF8.GetByteCount(label);
2593  if (labelByteCount > Util.StackAllocationSizeLimit)
2594  {
2595  nativeLabel = Util.Allocate(labelByteCount + 1);
2596  }
2597  else
2598  {
2599  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2600  nativeLabel = nativeLabelStackBytes;
2601  }
2602 
2603  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2604  nativeLabel[nativeLabelOffset] = 0;
2605  }
2606  else
2607  {
2608  nativeLabel = null;
2609  }
2610 
2611  fixed (Vector4F* nativeCol = &col)
2612  {
2613  byte ret = ImGuiNative.igColorEdit4(nativeLabel, nativeCol, flag);
2614  if (labelByteCount > Util.StackAllocationSizeLimit)
2615  {
2616  Util.Free(nativeLabel);
2617  }
2618 
2619  return ret != 0;
2620  }
2621  }
2622 
2629  public static bool ColorPicker3(string label, ref Vector3F col)
2630  {
2631  byte* nativeLabel;
2632  int labelByteCount = 0;
2633  if (label != null)
2634  {
2635  labelByteCount = Encoding.UTF8.GetByteCount(label);
2636  if (labelByteCount > Util.StackAllocationSizeLimit)
2637  {
2638  nativeLabel = Util.Allocate(labelByteCount + 1);
2639  }
2640  else
2641  {
2642  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2643  nativeLabel = nativeLabelStackBytes;
2644  }
2645 
2646  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2647  nativeLabel[nativeLabelOffset] = 0;
2648  }
2649  else
2650  {
2651  nativeLabel = null;
2652  }
2653 
2654  ImGuiColorEdits flag = 0;
2655  fixed (Vector3F* nativeCol = &col)
2656  {
2657  byte ret = ImGuiNative.igColorPicker3(nativeLabel, nativeCol, flag);
2658  if (labelByteCount > Util.StackAllocationSizeLimit)
2659  {
2660  Util.Free(nativeLabel);
2661  }
2662 
2663  return ret != 0;
2664  }
2665  }
2666 
2674  public static bool ColorPicker3(string label, ref Vector3F col, ImGuiColorEdits flag)
2675  {
2676  byte* nativeLabel;
2677  int labelByteCount = 0;
2678  if (label != null)
2679  {
2680  labelByteCount = Encoding.UTF8.GetByteCount(label);
2681  if (labelByteCount > Util.StackAllocationSizeLimit)
2682  {
2683  nativeLabel = Util.Allocate(labelByteCount + 1);
2684  }
2685  else
2686  {
2687  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2688  nativeLabel = nativeLabelStackBytes;
2689  }
2690 
2691  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2692  nativeLabel[nativeLabelOffset] = 0;
2693  }
2694  else
2695  {
2696  nativeLabel = null;
2697  }
2698 
2699  fixed (Vector3F* nativeCol = &col)
2700  {
2701  byte ret = ImGuiNative.igColorPicker3(nativeLabel, nativeCol, flag);
2702  if (labelByteCount > Util.StackAllocationSizeLimit)
2703  {
2704  Util.Free(nativeLabel);
2705  }
2706 
2707  return ret != 0;
2708  }
2709  }
2710 
2717  public static bool ColorPicker4(string label, ref Vector4F col)
2718  {
2719  byte* nativeLabel;
2720  int labelByteCount = 0;
2721  if (label != null)
2722  {
2723  labelByteCount = Encoding.UTF8.GetByteCount(label);
2724  if (labelByteCount > Util.StackAllocationSizeLimit)
2725  {
2726  nativeLabel = Util.Allocate(labelByteCount + 1);
2727  }
2728  else
2729  {
2730  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2731  nativeLabel = nativeLabelStackBytes;
2732  }
2733 
2734  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2735  nativeLabel[nativeLabelOffset] = 0;
2736  }
2737  else
2738  {
2739  nativeLabel = null;
2740  }
2741 
2742  ImGuiColorEdits flag = 0;
2743  float* refCol = null;
2744  fixed (Vector4F* nativeCol = &col)
2745  {
2746  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flag, refCol);
2747  if (labelByteCount > Util.StackAllocationSizeLimit)
2748  {
2749  Util.Free(nativeLabel);
2750  }
2751 
2752  return ret != 0;
2753  }
2754  }
2755 
2763  public static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEdits flag)
2764  {
2765  byte* nativeLabel;
2766  int labelByteCount = 0;
2767  if (label != null)
2768  {
2769  labelByteCount = Encoding.UTF8.GetByteCount(label);
2770  if (labelByteCount > Util.StackAllocationSizeLimit)
2771  {
2772  nativeLabel = Util.Allocate(labelByteCount + 1);
2773  }
2774  else
2775  {
2776  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2777  nativeLabel = nativeLabelStackBytes;
2778  }
2779 
2780  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2781  nativeLabel[nativeLabelOffset] = 0;
2782  }
2783  else
2784  {
2785  nativeLabel = null;
2786  }
2787 
2788  float* refCol = null;
2789  fixed (Vector4F* nativeCol = &col)
2790  {
2791  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flag, refCol);
2792  if (labelByteCount > Util.StackAllocationSizeLimit)
2793  {
2794  Util.Free(nativeLabel);
2795  }
2796 
2797  return ret != 0;
2798  }
2799  }
2800 
2809  public static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEdits flag, ref float refCol)
2810  {
2811  byte* nativeLabel;
2812  int labelByteCount = 0;
2813  if (label != null)
2814  {
2815  labelByteCount = Encoding.UTF8.GetByteCount(label);
2816  if (labelByteCount > Util.StackAllocationSizeLimit)
2817  {
2818  nativeLabel = Util.Allocate(labelByteCount + 1);
2819  }
2820  else
2821  {
2822  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2823  nativeLabel = nativeLabelStackBytes;
2824  }
2825 
2826  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2827  nativeLabel[nativeLabelOffset] = 0;
2828  }
2829  else
2830  {
2831  nativeLabel = null;
2832  }
2833 
2834  fixed (Vector4F* nativeCol = &col)
2835  {
2836  fixed (float* nativeRefCol = &refCol)
2837  {
2838  byte ret = ImGuiNative.igColorPicker4(nativeLabel, nativeCol, flag, nativeRefCol);
2839  if (labelByteCount > Util.StackAllocationSizeLimit)
2840  {
2841  Util.Free(nativeLabel);
2842  }
2843 
2844  return ret != 0;
2845  }
2846  }
2847  }
2848 
2852  public static void Columns()
2853  {
2854  int count = 1;
2855  byte* nativeId = null;
2856  byte border = 1;
2857  ImGuiNative.igColumns(count, nativeId, border);
2858  }
2859 
2864  public static void Columns(int count)
2865  {
2866  byte* nativeId = null;
2867  byte border = 1;
2868  ImGuiNative.igColumns(count, nativeId, border);
2869  }
2870 
2876  public static void Columns(int count, string id)
2877  {
2878  byte* nativeId;
2879  int idByteCount = 0;
2880  if (id != null)
2881  {
2882  idByteCount = Encoding.UTF8.GetByteCount(id);
2883  if (idByteCount > Util.StackAllocationSizeLimit)
2884  {
2885  nativeId = Util.Allocate(idByteCount + 1);
2886  }
2887  else
2888  {
2889  byte* nativeIdStackBytes = stackalloc byte[idByteCount + 1];
2890  nativeId = nativeIdStackBytes;
2891  }
2892 
2893  int nativeIdOffset = Util.GetUtf8(id, nativeId, idByteCount);
2894  nativeId[nativeIdOffset] = 0;
2895  }
2896  else
2897  {
2898  nativeId = null;
2899  }
2900 
2901  byte border = 1;
2902  ImGuiNative.igColumns(count, nativeId, border);
2903  if (idByteCount > Util.StackAllocationSizeLimit)
2904  {
2905  Util.Free(nativeId);
2906  }
2907  }
2908 
2915  public static void Columns(int count, string id, bool border)
2916  {
2917  byte* nativeId;
2918  int idByteCount = 0;
2919  if (id != null)
2920  {
2921  idByteCount = Encoding.UTF8.GetByteCount(id);
2922  if (idByteCount > Util.StackAllocationSizeLimit)
2923  {
2924  nativeId = Util.Allocate(idByteCount + 1);
2925  }
2926  else
2927  {
2928  byte* nativeIdStackBytes = stackalloc byte[idByteCount + 1];
2929  nativeId = nativeIdStackBytes;
2930  }
2931 
2932  int nativeIdOffset = Util.GetUtf8(id, nativeId, idByteCount);
2933  nativeId[nativeIdOffset] = 0;
2934  }
2935  else
2936  {
2937  nativeId = null;
2938  }
2939 
2940  byte nativeBorder = border ? (byte) 1 : (byte) 0;
2941  ImGuiNative.igColumns(count, nativeId, nativeBorder);
2942  if (idByteCount > Util.StackAllocationSizeLimit)
2943  {
2944  Util.Free(nativeId);
2945  }
2946  }
2947 
2956  public static bool Combo(string label, ref int currentItem, string[] items, int itemsCount)
2957  {
2958  byte* nativeLabel;
2959  int labelByteCount = 0;
2960  if (label != null)
2961  {
2962  labelByteCount = Encoding.UTF8.GetByteCount(label);
2963  if (labelByteCount > Util.StackAllocationSizeLimit)
2964  {
2965  nativeLabel = Util.Allocate(labelByteCount + 1);
2966  }
2967  else
2968  {
2969  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
2970  nativeLabel = nativeLabelStackBytes;
2971  }
2972 
2973  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
2974  nativeLabel[nativeLabelOffset] = 0;
2975  }
2976  else
2977  {
2978  nativeLabel = null;
2979  }
2980 
2981  int* itemsByteCounts = stackalloc int[items.Length];
2982  int itemsByteCount = 0;
2983  for (int i = 0; i < items.Length; i++)
2984  {
2985  string s = items[i];
2986  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
2987  itemsByteCount += itemsByteCounts[i] + 1;
2988  }
2989 
2990  byte* nativeItemsData = stackalloc byte[itemsByteCount];
2991  int offset = 0;
2992  for (int i = 0; i < items.Length; i++)
2993  {
2994  string s = items[i];
2995  fixed (char* sPtr = s)
2996  {
2997  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
2998  nativeItemsData[offset] = 0;
2999  offset += 1;
3000  }
3001  }
3002 
3003  byte** nativeItems = stackalloc byte*[items.Length];
3004  offset = 0;
3005  for (int i = 0; i < items.Length; i++)
3006  {
3007  nativeItems[i] = &nativeItemsData[offset];
3008  offset += itemsByteCounts[i] + 1;
3009  }
3010 
3011  int popupMaxHeightInItems = -1;
3012  fixed (int* nativeCurrentItem = &currentItem)
3013  {
3014  byte ret = ImGuiNative.igCombo_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, popupMaxHeightInItems);
3015  if (labelByteCount > Util.StackAllocationSizeLimit)
3016  {
3017  Util.Free(nativeLabel);
3018  }
3019 
3020  return ret != 0;
3021  }
3022  }
3023 
3033  public static bool Combo(string label, ref int currentItem, string[] items, int itemsCount, int popupMaxHeightInItems)
3034  {
3035  byte* nativeLabel;
3036  int labelByteCount = 0;
3037  if (label != null)
3038  {
3039  labelByteCount = Encoding.UTF8.GetByteCount(label);
3040  if (labelByteCount > Util.StackAllocationSizeLimit)
3041  {
3042  nativeLabel = Util.Allocate(labelByteCount + 1);
3043  }
3044  else
3045  {
3046  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3047  nativeLabel = nativeLabelStackBytes;
3048  }
3049 
3050  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3051  nativeLabel[nativeLabelOffset] = 0;
3052  }
3053  else
3054  {
3055  nativeLabel = null;
3056  }
3057 
3058  int* itemsByteCounts = stackalloc int[items.Length];
3059  int itemsByteCount = 0;
3060  for (int i = 0; i < items.Length; i++)
3061  {
3062  string s = items[i];
3063  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
3064  itemsByteCount += itemsByteCounts[i] + 1;
3065  }
3066 
3067  byte* nativeItemsData = stackalloc byte[itemsByteCount];
3068  int offset = 0;
3069  for (int i = 0; i < items.Length; i++)
3070  {
3071  string s = items[i];
3072  fixed (char* sPtr = s)
3073  {
3074  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
3075  nativeItemsData[offset] = 0;
3076  offset += 1;
3077  }
3078  }
3079 
3080  byte** nativeItems = stackalloc byte*[items.Length];
3081  offset = 0;
3082  for (int i = 0; i < items.Length; i++)
3083  {
3084  nativeItems[i] = &nativeItemsData[offset];
3085  offset += itemsByteCounts[i] + 1;
3086  }
3087 
3088  fixed (int* nativeCurrentItem = &currentItem)
3089  {
3090  byte ret = ImGuiNative.igCombo_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, popupMaxHeightInItems);
3091  if (labelByteCount > Util.StackAllocationSizeLimit)
3092  {
3093  Util.Free(nativeLabel);
3094  }
3095 
3096  return ret != 0;
3097  }
3098  }
3099 
3107  public static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros)
3108  {
3109  byte* nativeLabel;
3110  int labelByteCount = 0;
3111  if (label != null)
3112  {
3113  labelByteCount = Encoding.UTF8.GetByteCount(label);
3114  if (labelByteCount > Util.StackAllocationSizeLimit)
3115  {
3116  nativeLabel = Util.Allocate(labelByteCount + 1);
3117  }
3118  else
3119  {
3120  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3121  nativeLabel = nativeLabelStackBytes;
3122  }
3123 
3124  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3125  nativeLabel[nativeLabelOffset] = 0;
3126  }
3127  else
3128  {
3129  nativeLabel = null;
3130  }
3131 
3132  byte* nativeItemsSeparatedByZeros;
3133  int itemsSeparatedByZerosByteCount = 0;
3134  if (itemsSeparatedByZeros != null)
3135  {
3136  itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3137  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3138  {
3139  nativeItemsSeparatedByZeros = Util.Allocate(itemsSeparatedByZerosByteCount + 1);
3140  }
3141  else
3142  {
3143  byte* nativeItemsSeparatedByZerosStackBytes = stackalloc byte[itemsSeparatedByZerosByteCount + 1];
3144  nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3145  }
3146 
3147  int nativeItemsSeparatedByZerosOffset = Util.GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3148  nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3149  }
3150  else
3151  {
3152  nativeItemsSeparatedByZeros = null;
3153  }
3154 
3155  int popupMaxHeightInItems = -1;
3156  fixed (int* nativeCurrentItem = &currentItem)
3157  {
3158  byte ret = ImGuiNative.igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3159  if (labelByteCount > Util.StackAllocationSizeLimit)
3160  {
3161  Util.Free(nativeLabel);
3162  }
3163 
3164  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3165  {
3166  Util.Free(nativeItemsSeparatedByZeros);
3167  }
3168 
3169  return ret != 0;
3170  }
3171  }
3172 
3181  public static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros, int popupMaxHeightInItems)
3182  {
3183  byte* nativeLabel;
3184  int labelByteCount = 0;
3185  if (label != null)
3186  {
3187  labelByteCount = Encoding.UTF8.GetByteCount(label);
3188  if (labelByteCount > Util.StackAllocationSizeLimit)
3189  {
3190  nativeLabel = Util.Allocate(labelByteCount + 1);
3191  }
3192  else
3193  {
3194  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3195  nativeLabel = nativeLabelStackBytes;
3196  }
3197 
3198  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3199  nativeLabel[nativeLabelOffset] = 0;
3200  }
3201  else
3202  {
3203  nativeLabel = null;
3204  }
3205 
3206  byte* nativeItemsSeparatedByZeros;
3207  int itemsSeparatedByZerosByteCount = 0;
3208  if (itemsSeparatedByZeros != null)
3209  {
3210  itemsSeparatedByZerosByteCount = Encoding.UTF8.GetByteCount(itemsSeparatedByZeros);
3211  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3212  {
3213  nativeItemsSeparatedByZeros = Util.Allocate(itemsSeparatedByZerosByteCount + 1);
3214  }
3215  else
3216  {
3217  byte* nativeItemsSeparatedByZerosStackBytes = stackalloc byte[itemsSeparatedByZerosByteCount + 1];
3218  nativeItemsSeparatedByZeros = nativeItemsSeparatedByZerosStackBytes;
3219  }
3220 
3221  int nativeItemsSeparatedByZerosOffset = Util.GetUtf8(itemsSeparatedByZeros, nativeItemsSeparatedByZeros, itemsSeparatedByZerosByteCount);
3222  nativeItemsSeparatedByZeros[nativeItemsSeparatedByZerosOffset] = 0;
3223  }
3224  else
3225  {
3226  nativeItemsSeparatedByZeros = null;
3227  }
3228 
3229  fixed (int* nativeCurrentItem = &currentItem)
3230  {
3231  byte ret = ImGuiNative.igCombo_Str(nativeLabel, nativeCurrentItem, nativeItemsSeparatedByZeros, popupMaxHeightInItems);
3232  if (labelByteCount > Util.StackAllocationSizeLimit)
3233  {
3234  Util.Free(nativeLabel);
3235  }
3236 
3237  if (itemsSeparatedByZerosByteCount > Util.StackAllocationSizeLimit)
3238  {
3239  Util.Free(nativeItemsSeparatedByZeros);
3240  }
3241 
3242  return ret != 0;
3243  }
3244  }
3245 
3250  public static IntPtr CreateContext()
3251  {
3252  ImFontAtlas* sharedFontAtlas = null;
3253  IntPtr ret = ImGuiNative.igCreateContext(sharedFontAtlas);
3254  return ret;
3255  }
3256 
3262  public static IntPtr CreateContext(ImFontAtlasPtr sharedFontAtlas)
3263  {
3264  ImFontAtlas* nativeSharedFontAtlas = sharedFontAtlas.NativePtr;
3265  IntPtr ret = ImGuiNative.igCreateContext(nativeSharedFontAtlas);
3266  return ret;
3267  }
3268 
3280  public static bool DebugCheckVersionAndDataLayout(string versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
3281  {
3282  byte* nativeVersionStr;
3283  int versionStrByteCount = 0;
3284  if (versionStr != null)
3285  {
3286  versionStrByteCount = Encoding.UTF8.GetByteCount(versionStr);
3287  if (versionStrByteCount > Util.StackAllocationSizeLimit)
3288  {
3289  nativeVersionStr = Util.Allocate(versionStrByteCount + 1);
3290  }
3291  else
3292  {
3293  byte* nativeVersionStrStackBytes = stackalloc byte[versionStrByteCount + 1];
3294  nativeVersionStr = nativeVersionStrStackBytes;
3295  }
3296 
3297  int nativeVersionStrOffset = Util.GetUtf8(versionStr, nativeVersionStr, versionStrByteCount);
3298  nativeVersionStr[nativeVersionStrOffset] = 0;
3299  }
3300  else
3301  {
3302  nativeVersionStr = null;
3303  }
3304 
3305  byte ret = ImGuiNative.igDebugCheckVersionAndDataLayout(nativeVersionStr, szIo, szStyle, szVec2, szVec4, szDrawvert, szDrawidx);
3306  if (versionStrByteCount > Util.StackAllocationSizeLimit)
3307  {
3308  Util.Free(nativeVersionStr);
3309  }
3310 
3311  return ret != 0;
3312  }
3313 
3318  public static void DebugTextEncoding(string text)
3319  {
3320  byte* nativeText;
3321  int textByteCount = 0;
3322  if (text != null)
3323  {
3324  textByteCount = Encoding.UTF8.GetByteCount(text);
3325  if (textByteCount > Util.StackAllocationSizeLimit)
3326  {
3327  nativeText = Util.Allocate(textByteCount + 1);
3328  }
3329  else
3330  {
3331  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
3332  nativeText = nativeTextStackBytes;
3333  }
3334 
3335  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
3336  nativeText[nativeTextOffset] = 0;
3337  }
3338  else
3339  {
3340  nativeText = null;
3341  }
3342 
3343  ImGuiNative.igDebugTextEncoding(nativeText);
3344  if (textByteCount > Util.StackAllocationSizeLimit)
3345  {
3346  Util.Free(nativeText);
3347  }
3348  }
3349 
3353  public static void DestroyContext()
3354  {
3355  IntPtr ctx = IntPtr.Zero;
3357  }
3358 
3363  public static void DestroyContext(IntPtr ctx)
3364  {
3366  }
3367 
3371  public static void DestroyPlatformWindows()
3372  {
3374  }
3375 
3381  public static uint DockSpace(uint id)
3382  {
3383  Vector2F size = new Vector2F();
3384  ImGuiDockNodes flag = 0;
3385  ImGuiWindowClass* windowClass = null;
3386  uint ret = ImGuiNative.igDockSpace(id, size, flag, windowClass);
3387  return ret;
3388  }
3389 
3396  public static uint DockSpace(uint id, Vector2F size)
3397  {
3398  ImGuiDockNodes flag = 0;
3399  ImGuiWindowClass* windowClass = null;
3400  uint ret = ImGuiNative.igDockSpace(id, size, flag, windowClass);
3401  return ret;
3402  }
3403 
3411  public static uint DockSpace(uint id, Vector2F size, ImGuiDockNodes flag)
3412  {
3413  ImGuiWindowClass* windowClass = null;
3414  uint ret = ImGuiNative.igDockSpace(id, size, flag, windowClass);
3415  return ret;
3416  }
3417 
3426  public static uint DockSpace(uint id, Vector2F size, ImGuiDockNodes flag, ImGuiWindowClassPtr windowClass)
3427  {
3428  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
3429  uint ret = ImGuiNative.igDockSpace(id, size, flag, nativeWindowClass);
3430  return ret;
3431  }
3432 
3437  public static uint DockSpaceOverViewport()
3438  {
3439  ImGuiViewport* viewport = null;
3440  ImGuiDockNodes flag = 0;
3441  ImGuiWindowClass* windowClass = null;
3442  uint ret = ImGuiNative.igDockSpaceOverViewport(viewport, flag, windowClass);
3443  return ret;
3444  }
3445 
3451  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
3452  {
3453  ImGuiViewport* nativeViewport = viewport.NativePtr;
3454  ImGuiDockNodes flag = 0;
3455  ImGuiWindowClass* windowClass = null;
3456  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flag, windowClass);
3457  return ret;
3458  }
3459 
3466  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodes flag)
3467  {
3468  ImGuiViewport* nativeViewport = viewport.NativePtr;
3469  ImGuiWindowClass* windowClass = null;
3470  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flag, windowClass);
3471  return ret;
3472  }
3473 
3481  public static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodes flag, ImGuiWindowClassPtr windowClass)
3482  {
3483  ImGuiViewport* nativeViewport = viewport.NativePtr;
3484  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
3485  uint ret = ImGuiNative.igDockSpaceOverViewport(nativeViewport, flag, nativeWindowClass);
3486  return ret;
3487  }
3488 
3495  public static bool DragFloat(string label, ref float v)
3496  {
3497  byte* nativeLabel;
3498  int labelByteCount = 0;
3499  if (label != null)
3500  {
3501  labelByteCount = Encoding.UTF8.GetByteCount(label);
3502  if (labelByteCount > Util.StackAllocationSizeLimit)
3503  {
3504  nativeLabel = Util.Allocate(labelByteCount + 1);
3505  }
3506  else
3507  {
3508  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3509  nativeLabel = nativeLabelStackBytes;
3510  }
3511 
3512  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3513  nativeLabel[nativeLabelOffset] = 0;
3514  }
3515  else
3516  {
3517  nativeLabel = null;
3518  }
3519 
3520  float vSpeed = 1.0f;
3521  float vMin = 0.0f;
3522  float vMax = 0.0f;
3523  byte* nativeFormat;
3524  int formatByteCount = 0;
3525  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3526  if (formatByteCount > Util.StackAllocationSizeLimit)
3527  {
3528  nativeFormat = Util.Allocate(formatByteCount + 1);
3529  }
3530  else
3531  {
3532  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3533  nativeFormat = nativeFormatStackBytes;
3534  }
3535 
3536  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3537  nativeFormat[nativeFormatOffset] = 0;
3538  ImGuiSliders flag = 0;
3539  fixed (float* nativeV = &v)
3540  {
3541  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3542  if (labelByteCount > Util.StackAllocationSizeLimit)
3543  {
3544  Util.Free(nativeLabel);
3545  }
3546 
3547  if (formatByteCount > Util.StackAllocationSizeLimit)
3548  {
3549  Util.Free(nativeFormat);
3550  }
3551 
3552  return ret != 0;
3553  }
3554  }
3555 
3563  public static bool DragFloat(string label, ref float v, float vSpeed)
3564  {
3565  byte* nativeLabel;
3566  int labelByteCount = 0;
3567  if (label != null)
3568  {
3569  labelByteCount = Encoding.UTF8.GetByteCount(label);
3570  if (labelByteCount > Util.StackAllocationSizeLimit)
3571  {
3572  nativeLabel = Util.Allocate(labelByteCount + 1);
3573  }
3574  else
3575  {
3576  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3577  nativeLabel = nativeLabelStackBytes;
3578  }
3579 
3580  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3581  nativeLabel[nativeLabelOffset] = 0;
3582  }
3583  else
3584  {
3585  nativeLabel = null;
3586  }
3587 
3588  float vMin = 0.0f;
3589  float vMax = 0.0f;
3590  byte* nativeFormat;
3591  int formatByteCount = 0;
3592  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3593  if (formatByteCount > Util.StackAllocationSizeLimit)
3594  {
3595  nativeFormat = Util.Allocate(formatByteCount + 1);
3596  }
3597  else
3598  {
3599  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3600  nativeFormat = nativeFormatStackBytes;
3601  }
3602 
3603  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3604  nativeFormat[nativeFormatOffset] = 0;
3605  ImGuiSliders flag = 0;
3606  fixed (float* nativeV = &v)
3607  {
3608  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3609  if (labelByteCount > Util.StackAllocationSizeLimit)
3610  {
3611  Util.Free(nativeLabel);
3612  }
3613 
3614  if (formatByteCount > Util.StackAllocationSizeLimit)
3615  {
3616  Util.Free(nativeFormat);
3617  }
3618 
3619  return ret != 0;
3620  }
3621  }
3622 
3631  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin)
3632  {
3633  byte* nativeLabel;
3634  int labelByteCount = 0;
3635  if (label != null)
3636  {
3637  labelByteCount = Encoding.UTF8.GetByteCount(label);
3638  if (labelByteCount > Util.StackAllocationSizeLimit)
3639  {
3640  nativeLabel = Util.Allocate(labelByteCount + 1);
3641  }
3642  else
3643  {
3644  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3645  nativeLabel = nativeLabelStackBytes;
3646  }
3647 
3648  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3649  nativeLabel[nativeLabelOffset] = 0;
3650  }
3651  else
3652  {
3653  nativeLabel = null;
3654  }
3655 
3656  float vMax = 0.0f;
3657  byte* nativeFormat;
3658  int formatByteCount = 0;
3659  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3660  if (formatByteCount > Util.StackAllocationSizeLimit)
3661  {
3662  nativeFormat = Util.Allocate(formatByteCount + 1);
3663  }
3664  else
3665  {
3666  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3667  nativeFormat = nativeFormatStackBytes;
3668  }
3669 
3670  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3671  nativeFormat[nativeFormatOffset] = 0;
3672  ImGuiSliders flag = 0;
3673  fixed (float* nativeV = &v)
3674  {
3675  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3676  if (labelByteCount > Util.StackAllocationSizeLimit)
3677  {
3678  Util.Free(nativeLabel);
3679  }
3680 
3681  if (formatByteCount > Util.StackAllocationSizeLimit)
3682  {
3683  Util.Free(nativeFormat);
3684  }
3685 
3686  return ret != 0;
3687  }
3688  }
3689 
3699  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax)
3700  {
3701  byte* nativeLabel;
3702  int labelByteCount = 0;
3703  if (label != null)
3704  {
3705  labelByteCount = Encoding.UTF8.GetByteCount(label);
3706  if (labelByteCount > Util.StackAllocationSizeLimit)
3707  {
3708  nativeLabel = Util.Allocate(labelByteCount + 1);
3709  }
3710  else
3711  {
3712  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3713  nativeLabel = nativeLabelStackBytes;
3714  }
3715 
3716  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3717  nativeLabel[nativeLabelOffset] = 0;
3718  }
3719  else
3720  {
3721  nativeLabel = null;
3722  }
3723 
3724  byte* nativeFormat;
3725  int formatByteCount = 0;
3726  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3727  if (formatByteCount > Util.StackAllocationSizeLimit)
3728  {
3729  nativeFormat = Util.Allocate(formatByteCount + 1);
3730  }
3731  else
3732  {
3733  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3734  nativeFormat = nativeFormatStackBytes;
3735  }
3736 
3737  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3738  nativeFormat[nativeFormatOffset] = 0;
3739  ImGuiSliders flag = 0;
3740  fixed (float* nativeV = &v)
3741  {
3742  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3743  if (labelByteCount > Util.StackAllocationSizeLimit)
3744  {
3745  Util.Free(nativeLabel);
3746  }
3747 
3748  if (formatByteCount > Util.StackAllocationSizeLimit)
3749  {
3750  Util.Free(nativeFormat);
3751  }
3752 
3753  return ret != 0;
3754  }
3755  }
3756 
3767  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format)
3768  {
3769  byte* nativeLabel;
3770  int labelByteCount = 0;
3771  if (label != null)
3772  {
3773  labelByteCount = Encoding.UTF8.GetByteCount(label);
3774  if (labelByteCount > Util.StackAllocationSizeLimit)
3775  {
3776  nativeLabel = Util.Allocate(labelByteCount + 1);
3777  }
3778  else
3779  {
3780  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3781  nativeLabel = nativeLabelStackBytes;
3782  }
3783 
3784  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3785  nativeLabel[nativeLabelOffset] = 0;
3786  }
3787  else
3788  {
3789  nativeLabel = null;
3790  }
3791 
3792  byte* nativeFormat;
3793  int formatByteCount = 0;
3794  if (format != null)
3795  {
3796  formatByteCount = Encoding.UTF8.GetByteCount(format);
3797  if (formatByteCount > Util.StackAllocationSizeLimit)
3798  {
3799  nativeFormat = Util.Allocate(formatByteCount + 1);
3800  }
3801  else
3802  {
3803  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3804  nativeFormat = nativeFormatStackBytes;
3805  }
3806 
3807  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
3808  nativeFormat[nativeFormatOffset] = 0;
3809  }
3810  else
3811  {
3812  nativeFormat = null;
3813  }
3814 
3815  ImGuiSliders flag = 0;
3816  fixed (float* nativeV = &v)
3817  {
3818  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3819  if (labelByteCount > Util.StackAllocationSizeLimit)
3820  {
3821  Util.Free(nativeLabel);
3822  }
3823 
3824  if (formatByteCount > Util.StackAllocationSizeLimit)
3825  {
3826  Util.Free(nativeFormat);
3827  }
3828 
3829  return ret != 0;
3830  }
3831  }
3832 
3844  public static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
3845  {
3846  byte* nativeLabel;
3847  int labelByteCount = 0;
3848  if (label != null)
3849  {
3850  labelByteCount = Encoding.UTF8.GetByteCount(label);
3851  if (labelByteCount > Util.StackAllocationSizeLimit)
3852  {
3853  nativeLabel = Util.Allocate(labelByteCount + 1);
3854  }
3855  else
3856  {
3857  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3858  nativeLabel = nativeLabelStackBytes;
3859  }
3860 
3861  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3862  nativeLabel[nativeLabelOffset] = 0;
3863  }
3864  else
3865  {
3866  nativeLabel = null;
3867  }
3868 
3869  byte* nativeFormat;
3870  int formatByteCount = 0;
3871  if (format != null)
3872  {
3873  formatByteCount = Encoding.UTF8.GetByteCount(format);
3874  if (formatByteCount > Util.StackAllocationSizeLimit)
3875  {
3876  nativeFormat = Util.Allocate(formatByteCount + 1);
3877  }
3878  else
3879  {
3880  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3881  nativeFormat = nativeFormatStackBytes;
3882  }
3883 
3884  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
3885  nativeFormat[nativeFormatOffset] = 0;
3886  }
3887  else
3888  {
3889  nativeFormat = null;
3890  }
3891 
3892  fixed (float* nativeV = &v)
3893  {
3894  byte ret = ImGuiNative.igDragFloat(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3895  if (labelByteCount > Util.StackAllocationSizeLimit)
3896  {
3897  Util.Free(nativeLabel);
3898  }
3899 
3900  if (formatByteCount > Util.StackAllocationSizeLimit)
3901  {
3902  Util.Free(nativeFormat);
3903  }
3904 
3905  return ret != 0;
3906  }
3907  }
3908 
3915  public static bool DragFloat2(string label, ref Vector2F v)
3916  {
3917  byte* nativeLabel;
3918  int labelByteCount = 0;
3919  if (label != null)
3920  {
3921  labelByteCount = Encoding.UTF8.GetByteCount(label);
3922  if (labelByteCount > Util.StackAllocationSizeLimit)
3923  {
3924  nativeLabel = Util.Allocate(labelByteCount + 1);
3925  }
3926  else
3927  {
3928  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3929  nativeLabel = nativeLabelStackBytes;
3930  }
3931 
3932  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
3933  nativeLabel[nativeLabelOffset] = 0;
3934  }
3935  else
3936  {
3937  nativeLabel = null;
3938  }
3939 
3940  float vSpeed = 1.0f;
3941  float vMin = 0.0f;
3942  float vMax = 0.0f;
3943  byte* nativeFormat;
3944  int formatByteCount = 0;
3945  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
3946  if (formatByteCount > Util.StackAllocationSizeLimit)
3947  {
3948  nativeFormat = Util.Allocate(formatByteCount + 1);
3949  }
3950  else
3951  {
3952  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
3953  nativeFormat = nativeFormatStackBytes;
3954  }
3955 
3956  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
3957  nativeFormat[nativeFormatOffset] = 0;
3958  ImGuiSliders flag = 0;
3959  fixed (Vector2F* nativeV = &v)
3960  {
3961  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
3962  if (labelByteCount > Util.StackAllocationSizeLimit)
3963  {
3964  Util.Free(nativeLabel);
3965  }
3966 
3967  if (formatByteCount > Util.StackAllocationSizeLimit)
3968  {
3969  Util.Free(nativeFormat);
3970  }
3971 
3972  return ret != 0;
3973  }
3974  }
3975 
3983  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed)
3984  {
3985  byte* nativeLabel;
3986  int labelByteCount = 0;
3987  if (label != null)
3988  {
3989  labelByteCount = Encoding.UTF8.GetByteCount(label);
3990  if (labelByteCount > Util.StackAllocationSizeLimit)
3991  {
3992  nativeLabel = Util.Allocate(labelByteCount + 1);
3993  }
3994  else
3995  {
3996  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
3997  nativeLabel = nativeLabelStackBytes;
3998  }
3999 
4000  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4001  nativeLabel[nativeLabelOffset] = 0;
4002  }
4003  else
4004  {
4005  nativeLabel = null;
4006  }
4007 
4008  float vMin = 0.0f;
4009  float vMax = 0.0f;
4010  byte* nativeFormat;
4011  int formatByteCount = 0;
4012  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4013  if (formatByteCount > Util.StackAllocationSizeLimit)
4014  {
4015  nativeFormat = Util.Allocate(formatByteCount + 1);
4016  }
4017  else
4018  {
4019  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4020  nativeFormat = nativeFormatStackBytes;
4021  }
4022 
4023  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4024  nativeFormat[nativeFormatOffset] = 0;
4025  ImGuiSliders flag = 0;
4026  fixed (Vector2F* nativeV = &v)
4027  {
4028  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4029  if (labelByteCount > Util.StackAllocationSizeLimit)
4030  {
4031  Util.Free(nativeLabel);
4032  }
4033 
4034  if (formatByteCount > Util.StackAllocationSizeLimit)
4035  {
4036  Util.Free(nativeFormat);
4037  }
4038 
4039  return ret != 0;
4040  }
4041  }
4042 
4051  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin)
4052  {
4053  byte* nativeLabel;
4054  int labelByteCount = 0;
4055  if (label != null)
4056  {
4057  labelByteCount = Encoding.UTF8.GetByteCount(label);
4058  if (labelByteCount > Util.StackAllocationSizeLimit)
4059  {
4060  nativeLabel = Util.Allocate(labelByteCount + 1);
4061  }
4062  else
4063  {
4064  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4065  nativeLabel = nativeLabelStackBytes;
4066  }
4067 
4068  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4069  nativeLabel[nativeLabelOffset] = 0;
4070  }
4071  else
4072  {
4073  nativeLabel = null;
4074  }
4075 
4076  float vMax = 0.0f;
4077  byte* nativeFormat;
4078  int formatByteCount = 0;
4079  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4080  if (formatByteCount > Util.StackAllocationSizeLimit)
4081  {
4082  nativeFormat = Util.Allocate(formatByteCount + 1);
4083  }
4084  else
4085  {
4086  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4087  nativeFormat = nativeFormatStackBytes;
4088  }
4089 
4090  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4091  nativeFormat[nativeFormatOffset] = 0;
4092  ImGuiSliders flag = 0;
4093  fixed (Vector2F* nativeV = &v)
4094  {
4095  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4096  if (labelByteCount > Util.StackAllocationSizeLimit)
4097  {
4098  Util.Free(nativeLabel);
4099  }
4100 
4101  if (formatByteCount > Util.StackAllocationSizeLimit)
4102  {
4103  Util.Free(nativeFormat);
4104  }
4105 
4106  return ret != 0;
4107  }
4108  }
4109 
4119  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax)
4120  {
4121  byte* nativeLabel;
4122  int labelByteCount = 0;
4123  if (label != null)
4124  {
4125  labelByteCount = Encoding.UTF8.GetByteCount(label);
4126  if (labelByteCount > Util.StackAllocationSizeLimit)
4127  {
4128  nativeLabel = Util.Allocate(labelByteCount + 1);
4129  }
4130  else
4131  {
4132  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4133  nativeLabel = nativeLabelStackBytes;
4134  }
4135 
4136  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4137  nativeLabel[nativeLabelOffset] = 0;
4138  }
4139  else
4140  {
4141  nativeLabel = null;
4142  }
4143 
4144  byte* nativeFormat;
4145  int formatByteCount = 0;
4146  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4147  if (formatByteCount > Util.StackAllocationSizeLimit)
4148  {
4149  nativeFormat = Util.Allocate(formatByteCount + 1);
4150  }
4151  else
4152  {
4153  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4154  nativeFormat = nativeFormatStackBytes;
4155  }
4156 
4157  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4158  nativeFormat[nativeFormatOffset] = 0;
4159  ImGuiSliders flag = 0;
4160  fixed (Vector2F* nativeV = &v)
4161  {
4162  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4163  if (labelByteCount > Util.StackAllocationSizeLimit)
4164  {
4165  Util.Free(nativeLabel);
4166  }
4167 
4168  if (formatByteCount > Util.StackAllocationSizeLimit)
4169  {
4170  Util.Free(nativeFormat);
4171  }
4172 
4173  return ret != 0;
4174  }
4175  }
4176 
4187  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format)
4188  {
4189  byte* nativeLabel;
4190  int labelByteCount = 0;
4191  if (label != null)
4192  {
4193  labelByteCount = Encoding.UTF8.GetByteCount(label);
4194  if (labelByteCount > Util.StackAllocationSizeLimit)
4195  {
4196  nativeLabel = Util.Allocate(labelByteCount + 1);
4197  }
4198  else
4199  {
4200  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4201  nativeLabel = nativeLabelStackBytes;
4202  }
4203 
4204  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4205  nativeLabel[nativeLabelOffset] = 0;
4206  }
4207  else
4208  {
4209  nativeLabel = null;
4210  }
4211 
4212  byte* nativeFormat;
4213  int formatByteCount = 0;
4214  if (format != null)
4215  {
4216  formatByteCount = Encoding.UTF8.GetByteCount(format);
4217  if (formatByteCount > Util.StackAllocationSizeLimit)
4218  {
4219  nativeFormat = Util.Allocate(formatByteCount + 1);
4220  }
4221  else
4222  {
4223  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4224  nativeFormat = nativeFormatStackBytes;
4225  }
4226 
4227  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4228  nativeFormat[nativeFormatOffset] = 0;
4229  }
4230  else
4231  {
4232  nativeFormat = null;
4233  }
4234 
4235  ImGuiSliders flag = 0;
4236  fixed (Vector2F* nativeV = &v)
4237  {
4238  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4239  if (labelByteCount > Util.StackAllocationSizeLimit)
4240  {
4241  Util.Free(nativeLabel);
4242  }
4243 
4244  if (formatByteCount > Util.StackAllocationSizeLimit)
4245  {
4246  Util.Free(nativeFormat);
4247  }
4248 
4249  return ret != 0;
4250  }
4251  }
4252 
4264  public static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
4265  {
4266  byte* nativeLabel;
4267  int labelByteCount = 0;
4268  if (label != null)
4269  {
4270  labelByteCount = Encoding.UTF8.GetByteCount(label);
4271  if (labelByteCount > Util.StackAllocationSizeLimit)
4272  {
4273  nativeLabel = Util.Allocate(labelByteCount + 1);
4274  }
4275  else
4276  {
4277  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4278  nativeLabel = nativeLabelStackBytes;
4279  }
4280 
4281  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4282  nativeLabel[nativeLabelOffset] = 0;
4283  }
4284  else
4285  {
4286  nativeLabel = null;
4287  }
4288 
4289  byte* nativeFormat;
4290  int formatByteCount = 0;
4291  if (format != null)
4292  {
4293  formatByteCount = Encoding.UTF8.GetByteCount(format);
4294  if (formatByteCount > Util.StackAllocationSizeLimit)
4295  {
4296  nativeFormat = Util.Allocate(formatByteCount + 1);
4297  }
4298  else
4299  {
4300  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4301  nativeFormat = nativeFormatStackBytes;
4302  }
4303 
4304  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4305  nativeFormat[nativeFormatOffset] = 0;
4306  }
4307  else
4308  {
4309  nativeFormat = null;
4310  }
4311 
4312  fixed (Vector2F* nativeV = &v)
4313  {
4314  byte ret = ImGuiNative.igDragFloat2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4315  if (labelByteCount > Util.StackAllocationSizeLimit)
4316  {
4317  Util.Free(nativeLabel);
4318  }
4319 
4320  if (formatByteCount > Util.StackAllocationSizeLimit)
4321  {
4322  Util.Free(nativeFormat);
4323  }
4324 
4325  return ret != 0;
4326  }
4327  }
4328 
4335  public static bool DragFloat3(string label, ref Vector3F v)
4336  {
4337  byte* nativeLabel;
4338  int labelByteCount = 0;
4339  if (label != null)
4340  {
4341  labelByteCount = Encoding.UTF8.GetByteCount(label);
4342  if (labelByteCount > Util.StackAllocationSizeLimit)
4343  {
4344  nativeLabel = Util.Allocate(labelByteCount + 1);
4345  }
4346  else
4347  {
4348  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4349  nativeLabel = nativeLabelStackBytes;
4350  }
4351 
4352  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4353  nativeLabel[nativeLabelOffset] = 0;
4354  }
4355  else
4356  {
4357  nativeLabel = null;
4358  }
4359 
4360  float vSpeed = 1.0f;
4361  float vMin = 0.0f;
4362  float vMax = 0.0f;
4363  byte* nativeFormat;
4364  int formatByteCount = 0;
4365  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4366  if (formatByteCount > Util.StackAllocationSizeLimit)
4367  {
4368  nativeFormat = Util.Allocate(formatByteCount + 1);
4369  }
4370  else
4371  {
4372  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4373  nativeFormat = nativeFormatStackBytes;
4374  }
4375 
4376  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4377  nativeFormat[nativeFormatOffset] = 0;
4378  ImGuiSliders flag = 0;
4379  fixed (Vector3F* nativeV = &v)
4380  {
4381  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4382  if (labelByteCount > Util.StackAllocationSizeLimit)
4383  {
4384  Util.Free(nativeLabel);
4385  }
4386 
4387  if (formatByteCount > Util.StackAllocationSizeLimit)
4388  {
4389  Util.Free(nativeFormat);
4390  }
4391 
4392  return ret != 0;
4393  }
4394  }
4395 
4403  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed)
4404  {
4405  byte* nativeLabel;
4406  int labelByteCount = 0;
4407  if (label != null)
4408  {
4409  labelByteCount = Encoding.UTF8.GetByteCount(label);
4410  if (labelByteCount > Util.StackAllocationSizeLimit)
4411  {
4412  nativeLabel = Util.Allocate(labelByteCount + 1);
4413  }
4414  else
4415  {
4416  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4417  nativeLabel = nativeLabelStackBytes;
4418  }
4419 
4420  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4421  nativeLabel[nativeLabelOffset] = 0;
4422  }
4423  else
4424  {
4425  nativeLabel = null;
4426  }
4427 
4428  float vMin = 0.0f;
4429  float vMax = 0.0f;
4430  byte* nativeFormat;
4431  int formatByteCount = 0;
4432  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4433  if (formatByteCount > Util.StackAllocationSizeLimit)
4434  {
4435  nativeFormat = Util.Allocate(formatByteCount + 1);
4436  }
4437  else
4438  {
4439  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4440  nativeFormat = nativeFormatStackBytes;
4441  }
4442 
4443  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4444  nativeFormat[nativeFormatOffset] = 0;
4445  ImGuiSliders flag = 0;
4446  fixed (Vector3F* nativeV = &v)
4447  {
4448  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4449  if (labelByteCount > Util.StackAllocationSizeLimit)
4450  {
4451  Util.Free(nativeLabel);
4452  }
4453 
4454  if (formatByteCount > Util.StackAllocationSizeLimit)
4455  {
4456  Util.Free(nativeFormat);
4457  }
4458 
4459  return ret != 0;
4460  }
4461  }
4462 
4471  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin)
4472  {
4473  byte* nativeLabel;
4474  int labelByteCount = 0;
4475  if (label != null)
4476  {
4477  labelByteCount = Encoding.UTF8.GetByteCount(label);
4478  if (labelByteCount > Util.StackAllocationSizeLimit)
4479  {
4480  nativeLabel = Util.Allocate(labelByteCount + 1);
4481  }
4482  else
4483  {
4484  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4485  nativeLabel = nativeLabelStackBytes;
4486  }
4487 
4488  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4489  nativeLabel[nativeLabelOffset] = 0;
4490  }
4491  else
4492  {
4493  nativeLabel = null;
4494  }
4495 
4496  float vMax = 0.0f;
4497  byte* nativeFormat;
4498  int formatByteCount = 0;
4499  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4500  if (formatByteCount > Util.StackAllocationSizeLimit)
4501  {
4502  nativeFormat = Util.Allocate(formatByteCount + 1);
4503  }
4504  else
4505  {
4506  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4507  nativeFormat = nativeFormatStackBytes;
4508  }
4509 
4510  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4511  nativeFormat[nativeFormatOffset] = 0;
4512  ImGuiSliders flag = 0;
4513  fixed (Vector3F* nativeV = &v)
4514  {
4515  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4516  if (labelByteCount > Util.StackAllocationSizeLimit)
4517  {
4518  Util.Free(nativeLabel);
4519  }
4520 
4521  if (formatByteCount > Util.StackAllocationSizeLimit)
4522  {
4523  Util.Free(nativeFormat);
4524  }
4525 
4526  return ret != 0;
4527  }
4528  }
4529 
4539  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax)
4540  {
4541  byte* nativeLabel;
4542  int labelByteCount = 0;
4543  if (label != null)
4544  {
4545  labelByteCount = Encoding.UTF8.GetByteCount(label);
4546  if (labelByteCount > Util.StackAllocationSizeLimit)
4547  {
4548  nativeLabel = Util.Allocate(labelByteCount + 1);
4549  }
4550  else
4551  {
4552  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4553  nativeLabel = nativeLabelStackBytes;
4554  }
4555 
4556  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4557  nativeLabel[nativeLabelOffset] = 0;
4558  }
4559  else
4560  {
4561  nativeLabel = null;
4562  }
4563 
4564  byte* nativeFormat;
4565  int formatByteCount = 0;
4566  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4567  if (formatByteCount > Util.StackAllocationSizeLimit)
4568  {
4569  nativeFormat = Util.Allocate(formatByteCount + 1);
4570  }
4571  else
4572  {
4573  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4574  nativeFormat = nativeFormatStackBytes;
4575  }
4576 
4577  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4578  nativeFormat[nativeFormatOffset] = 0;
4579  ImGuiSliders flag = 0;
4580  fixed (Vector3F* nativeV = &v)
4581  {
4582  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4583  if (labelByteCount > Util.StackAllocationSizeLimit)
4584  {
4585  Util.Free(nativeLabel);
4586  }
4587 
4588  if (formatByteCount > Util.StackAllocationSizeLimit)
4589  {
4590  Util.Free(nativeFormat);
4591  }
4592 
4593  return ret != 0;
4594  }
4595  }
4596 
4607  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format)
4608  {
4609  byte* nativeLabel;
4610  int labelByteCount = 0;
4611  if (label != null)
4612  {
4613  labelByteCount = Encoding.UTF8.GetByteCount(label);
4614  if (labelByteCount > Util.StackAllocationSizeLimit)
4615  {
4616  nativeLabel = Util.Allocate(labelByteCount + 1);
4617  }
4618  else
4619  {
4620  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4621  nativeLabel = nativeLabelStackBytes;
4622  }
4623 
4624  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4625  nativeLabel[nativeLabelOffset] = 0;
4626  }
4627  else
4628  {
4629  nativeLabel = null;
4630  }
4631 
4632  byte* nativeFormat;
4633  int formatByteCount = 0;
4634  if (format != null)
4635  {
4636  formatByteCount = Encoding.UTF8.GetByteCount(format);
4637  if (formatByteCount > Util.StackAllocationSizeLimit)
4638  {
4639  nativeFormat = Util.Allocate(formatByteCount + 1);
4640  }
4641  else
4642  {
4643  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4644  nativeFormat = nativeFormatStackBytes;
4645  }
4646 
4647  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4648  nativeFormat[nativeFormatOffset] = 0;
4649  }
4650  else
4651  {
4652  nativeFormat = null;
4653  }
4654 
4655  ImGuiSliders flag = 0;
4656  fixed (Vector3F* nativeV = &v)
4657  {
4658  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4659  if (labelByteCount > Util.StackAllocationSizeLimit)
4660  {
4661  Util.Free(nativeLabel);
4662  }
4663 
4664  if (formatByteCount > Util.StackAllocationSizeLimit)
4665  {
4666  Util.Free(nativeFormat);
4667  }
4668 
4669  return ret != 0;
4670  }
4671  }
4672 
4684  public static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
4685  {
4686  byte* nativeLabel;
4687  int labelByteCount = 0;
4688  if (label != null)
4689  {
4690  labelByteCount = Encoding.UTF8.GetByteCount(label);
4691  if (labelByteCount > Util.StackAllocationSizeLimit)
4692  {
4693  nativeLabel = Util.Allocate(labelByteCount + 1);
4694  }
4695  else
4696  {
4697  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4698  nativeLabel = nativeLabelStackBytes;
4699  }
4700 
4701  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4702  nativeLabel[nativeLabelOffset] = 0;
4703  }
4704  else
4705  {
4706  nativeLabel = null;
4707  }
4708 
4709  byte* nativeFormat;
4710  int formatByteCount = 0;
4711  if (format != null)
4712  {
4713  formatByteCount = Encoding.UTF8.GetByteCount(format);
4714  if (formatByteCount > Util.StackAllocationSizeLimit)
4715  {
4716  nativeFormat = Util.Allocate(formatByteCount + 1);
4717  }
4718  else
4719  {
4720  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4721  nativeFormat = nativeFormatStackBytes;
4722  }
4723 
4724  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
4725  nativeFormat[nativeFormatOffset] = 0;
4726  }
4727  else
4728  {
4729  nativeFormat = null;
4730  }
4731 
4732  fixed (Vector3F* nativeV = &v)
4733  {
4734  byte ret = ImGuiNative.igDragFloat3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4735  if (labelByteCount > Util.StackAllocationSizeLimit)
4736  {
4737  Util.Free(nativeLabel);
4738  }
4739 
4740  if (formatByteCount > Util.StackAllocationSizeLimit)
4741  {
4742  Util.Free(nativeFormat);
4743  }
4744 
4745  return ret != 0;
4746  }
4747  }
4748 
4755  public static bool DragFloat4(string label, ref Vector4F v)
4756  {
4757  byte* nativeLabel;
4758  int labelByteCount = 0;
4759  if (label != null)
4760  {
4761  labelByteCount = Encoding.UTF8.GetByteCount(label);
4762  if (labelByteCount > Util.StackAllocationSizeLimit)
4763  {
4764  nativeLabel = Util.Allocate(labelByteCount + 1);
4765  }
4766  else
4767  {
4768  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4769  nativeLabel = nativeLabelStackBytes;
4770  }
4771 
4772  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4773  nativeLabel[nativeLabelOffset] = 0;
4774  }
4775  else
4776  {
4777  nativeLabel = null;
4778  }
4779 
4780  float vSpeed = 1.0f;
4781  float vMin = 0.0f;
4782  float vMax = 0.0f;
4783  byte* nativeFormat;
4784  int formatByteCount = 0;
4785  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4786  if (formatByteCount > Util.StackAllocationSizeLimit)
4787  {
4788  nativeFormat = Util.Allocate(formatByteCount + 1);
4789  }
4790  else
4791  {
4792  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4793  nativeFormat = nativeFormatStackBytes;
4794  }
4795 
4796  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4797  nativeFormat[nativeFormatOffset] = 0;
4798  ImGuiSliders flag = 0;
4799  fixed (Vector4F* nativeV = &v)
4800  {
4801  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4802  if (labelByteCount > Util.StackAllocationSizeLimit)
4803  {
4804  Util.Free(nativeLabel);
4805  }
4806 
4807  if (formatByteCount > Util.StackAllocationSizeLimit)
4808  {
4809  Util.Free(nativeFormat);
4810  }
4811 
4812  return ret != 0;
4813  }
4814  }
4815 
4823  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed)
4824  {
4825  byte* nativeLabel;
4826  int labelByteCount = 0;
4827  if (label != null)
4828  {
4829  labelByteCount = Encoding.UTF8.GetByteCount(label);
4830  if (labelByteCount > Util.StackAllocationSizeLimit)
4831  {
4832  nativeLabel = Util.Allocate(labelByteCount + 1);
4833  }
4834  else
4835  {
4836  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4837  nativeLabel = nativeLabelStackBytes;
4838  }
4839 
4840  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4841  nativeLabel[nativeLabelOffset] = 0;
4842  }
4843  else
4844  {
4845  nativeLabel = null;
4846  }
4847 
4848  float vMin = 0.0f;
4849  float vMax = 0.0f;
4850  byte* nativeFormat;
4851  int formatByteCount = 0;
4852  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4853  if (formatByteCount > Util.StackAllocationSizeLimit)
4854  {
4855  nativeFormat = Util.Allocate(formatByteCount + 1);
4856  }
4857  else
4858  {
4859  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4860  nativeFormat = nativeFormatStackBytes;
4861  }
4862 
4863  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4864  nativeFormat[nativeFormatOffset] = 0;
4865  ImGuiSliders flag = 0;
4866  fixed (Vector4F* nativeV = &v)
4867  {
4868  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4869  if (labelByteCount > Util.StackAllocationSizeLimit)
4870  {
4871  Util.Free(nativeLabel);
4872  }
4873 
4874  if (formatByteCount > Util.StackAllocationSizeLimit)
4875  {
4876  Util.Free(nativeFormat);
4877  }
4878 
4879  return ret != 0;
4880  }
4881  }
4882 
4891  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin)
4892  {
4893  byte* nativeLabel;
4894  int labelByteCount = 0;
4895  if (label != null)
4896  {
4897  labelByteCount = Encoding.UTF8.GetByteCount(label);
4898  if (labelByteCount > Util.StackAllocationSizeLimit)
4899  {
4900  nativeLabel = Util.Allocate(labelByteCount + 1);
4901  }
4902  else
4903  {
4904  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4905  nativeLabel = nativeLabelStackBytes;
4906  }
4907 
4908  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4909  nativeLabel[nativeLabelOffset] = 0;
4910  }
4911  else
4912  {
4913  nativeLabel = null;
4914  }
4915 
4916  float vMax = 0.0f;
4917  byte* nativeFormat;
4918  int formatByteCount = 0;
4919  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4920  if (formatByteCount > Util.StackAllocationSizeLimit)
4921  {
4922  nativeFormat = Util.Allocate(formatByteCount + 1);
4923  }
4924  else
4925  {
4926  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4927  nativeFormat = nativeFormatStackBytes;
4928  }
4929 
4930  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4931  nativeFormat[nativeFormatOffset] = 0;
4932  ImGuiSliders flag = 0;
4933  fixed (Vector4F* nativeV = &v)
4934  {
4935  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
4936  if (labelByteCount > Util.StackAllocationSizeLimit)
4937  {
4938  Util.Free(nativeLabel);
4939  }
4940 
4941  if (formatByteCount > Util.StackAllocationSizeLimit)
4942  {
4943  Util.Free(nativeFormat);
4944  }
4945 
4946  return ret != 0;
4947  }
4948  }
4949 
4959  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax)
4960  {
4961  byte* nativeLabel;
4962  int labelByteCount = 0;
4963  if (label != null)
4964  {
4965  labelByteCount = Encoding.UTF8.GetByteCount(label);
4966  if (labelByteCount > Util.StackAllocationSizeLimit)
4967  {
4968  nativeLabel = Util.Allocate(labelByteCount + 1);
4969  }
4970  else
4971  {
4972  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
4973  nativeLabel = nativeLabelStackBytes;
4974  }
4975 
4976  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
4977  nativeLabel[nativeLabelOffset] = 0;
4978  }
4979  else
4980  {
4981  nativeLabel = null;
4982  }
4983 
4984  byte* nativeFormat;
4985  int formatByteCount = 0;
4986  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
4987  if (formatByteCount > Util.StackAllocationSizeLimit)
4988  {
4989  nativeFormat = Util.Allocate(formatByteCount + 1);
4990  }
4991  else
4992  {
4993  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
4994  nativeFormat = nativeFormatStackBytes;
4995  }
4996 
4997  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
4998  nativeFormat[nativeFormatOffset] = 0;
4999  ImGuiSliders flag = 0;
5000  fixed (Vector4F* nativeV = &v)
5001  {
5002  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5003  if (labelByteCount > Util.StackAllocationSizeLimit)
5004  {
5005  Util.Free(nativeLabel);
5006  }
5007 
5008  if (formatByteCount > Util.StackAllocationSizeLimit)
5009  {
5010  Util.Free(nativeFormat);
5011  }
5012 
5013  return ret != 0;
5014  }
5015  }
5016 
5027  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format)
5028  {
5029  byte* nativeLabel;
5030  int labelByteCount = 0;
5031  if (label != null)
5032  {
5033  labelByteCount = Encoding.UTF8.GetByteCount(label);
5034  if (labelByteCount > Util.StackAllocationSizeLimit)
5035  {
5036  nativeLabel = Util.Allocate(labelByteCount + 1);
5037  }
5038  else
5039  {
5040  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5041  nativeLabel = nativeLabelStackBytes;
5042  }
5043 
5044  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5045  nativeLabel[nativeLabelOffset] = 0;
5046  }
5047  else
5048  {
5049  nativeLabel = null;
5050  }
5051 
5052  byte* nativeFormat;
5053  int formatByteCount = 0;
5054  if (format != null)
5055  {
5056  formatByteCount = Encoding.UTF8.GetByteCount(format);
5057  if (formatByteCount > Util.StackAllocationSizeLimit)
5058  {
5059  nativeFormat = Util.Allocate(formatByteCount + 1);
5060  }
5061  else
5062  {
5063  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5064  nativeFormat = nativeFormatStackBytes;
5065  }
5066 
5067  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5068  nativeFormat[nativeFormatOffset] = 0;
5069  }
5070  else
5071  {
5072  nativeFormat = null;
5073  }
5074 
5075  ImGuiSliders flag = 0;
5076  fixed (Vector4F* nativeV = &v)
5077  {
5078  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5079  if (labelByteCount > Util.StackAllocationSizeLimit)
5080  {
5081  Util.Free(nativeLabel);
5082  }
5083 
5084  if (formatByteCount > Util.StackAllocationSizeLimit)
5085  {
5086  Util.Free(nativeFormat);
5087  }
5088 
5089  return ret != 0;
5090  }
5091  }
5092 
5104  public static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
5105  {
5106  byte* nativeLabel;
5107  int labelByteCount = 0;
5108  if (label != null)
5109  {
5110  labelByteCount = Encoding.UTF8.GetByteCount(label);
5111  if (labelByteCount > Util.StackAllocationSizeLimit)
5112  {
5113  nativeLabel = Util.Allocate(labelByteCount + 1);
5114  }
5115  else
5116  {
5117  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5118  nativeLabel = nativeLabelStackBytes;
5119  }
5120 
5121  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5122  nativeLabel[nativeLabelOffset] = 0;
5123  }
5124  else
5125  {
5126  nativeLabel = null;
5127  }
5128 
5129  byte* nativeFormat;
5130  int formatByteCount = 0;
5131  if (format != null)
5132  {
5133  formatByteCount = Encoding.UTF8.GetByteCount(format);
5134  if (formatByteCount > Util.StackAllocationSizeLimit)
5135  {
5136  nativeFormat = Util.Allocate(formatByteCount + 1);
5137  }
5138  else
5139  {
5140  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5141  nativeFormat = nativeFormatStackBytes;
5142  }
5143 
5144  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5145  nativeFormat[nativeFormatOffset] = 0;
5146  }
5147  else
5148  {
5149  nativeFormat = null;
5150  }
5151 
5152  fixed (Vector4F* nativeV = &v)
5153  {
5154  byte ret = ImGuiNative.igDragFloat4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5155  if (labelByteCount > Util.StackAllocationSizeLimit)
5156  {
5157  Util.Free(nativeLabel);
5158  }
5159 
5160  if (formatByteCount > Util.StackAllocationSizeLimit)
5161  {
5162  Util.Free(nativeFormat);
5163  }
5164 
5165  return ret != 0;
5166  }
5167  }
5168 
5176  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax)
5177  {
5178  byte* nativeLabel;
5179  int labelByteCount = 0;
5180  if (label != null)
5181  {
5182  labelByteCount = Encoding.UTF8.GetByteCount(label);
5183  if (labelByteCount > Util.StackAllocationSizeLimit)
5184  {
5185  nativeLabel = Util.Allocate(labelByteCount + 1);
5186  }
5187  else
5188  {
5189  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5190  nativeLabel = nativeLabelStackBytes;
5191  }
5192 
5193  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5194  nativeLabel[nativeLabelOffset] = 0;
5195  }
5196  else
5197  {
5198  nativeLabel = null;
5199  }
5200 
5201  float vSpeed = 1.0f;
5202  float vMin = 0.0f;
5203  float vMax = 0.0f;
5204  byte* nativeFormat;
5205  int formatByteCount = 0;
5206  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5207  if (formatByteCount > Util.StackAllocationSizeLimit)
5208  {
5209  nativeFormat = Util.Allocate(formatByteCount + 1);
5210  }
5211  else
5212  {
5213  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5214  nativeFormat = nativeFormatStackBytes;
5215  }
5216 
5217  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5218  nativeFormat[nativeFormatOffset] = 0;
5219  byte* nativeFormatMax = null;
5220  ImGuiSliders flag = 0;
5221  fixed (float* nativeVCurrentMin = &vCurrentMin)
5222  {
5223  fixed (float* nativeVCurrentMax = &vCurrentMax)
5224  {
5225  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5226  if (labelByteCount > Util.StackAllocationSizeLimit)
5227  {
5228  Util.Free(nativeLabel);
5229  }
5230 
5231  if (formatByteCount > Util.StackAllocationSizeLimit)
5232  {
5233  Util.Free(nativeFormat);
5234  }
5235 
5236  return ret != 0;
5237  }
5238  }
5239  }
5240 
5249  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed)
5250  {
5251  byte* nativeLabel;
5252  int labelByteCount = 0;
5253  if (label != null)
5254  {
5255  labelByteCount = Encoding.UTF8.GetByteCount(label);
5256  if (labelByteCount > Util.StackAllocationSizeLimit)
5257  {
5258  nativeLabel = Util.Allocate(labelByteCount + 1);
5259  }
5260  else
5261  {
5262  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5263  nativeLabel = nativeLabelStackBytes;
5264  }
5265 
5266  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5267  nativeLabel[nativeLabelOffset] = 0;
5268  }
5269  else
5270  {
5271  nativeLabel = null;
5272  }
5273 
5274  float vMin = 0.0f;
5275  float vMax = 0.0f;
5276  byte* nativeFormat;
5277  int formatByteCount = 0;
5278  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5279  if (formatByteCount > Util.StackAllocationSizeLimit)
5280  {
5281  nativeFormat = Util.Allocate(formatByteCount + 1);
5282  }
5283  else
5284  {
5285  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5286  nativeFormat = nativeFormatStackBytes;
5287  }
5288 
5289  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5290  nativeFormat[nativeFormatOffset] = 0;
5291  byte* nativeFormatMax = null;
5292  ImGuiSliders flag = 0;
5293  fixed (float* nativeVCurrentMin = &vCurrentMin)
5294  {
5295  fixed (float* nativeVCurrentMax = &vCurrentMax)
5296  {
5297  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5298  if (labelByteCount > Util.StackAllocationSizeLimit)
5299  {
5300  Util.Free(nativeLabel);
5301  }
5302 
5303  if (formatByteCount > Util.StackAllocationSizeLimit)
5304  {
5305  Util.Free(nativeFormat);
5306  }
5307 
5308  return ret != 0;
5309  }
5310  }
5311  }
5312 
5322  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin)
5323  {
5324  byte* nativeLabel;
5325  int labelByteCount = 0;
5326  if (label != null)
5327  {
5328  labelByteCount = Encoding.UTF8.GetByteCount(label);
5329  if (labelByteCount > Util.StackAllocationSizeLimit)
5330  {
5331  nativeLabel = Util.Allocate(labelByteCount + 1);
5332  }
5333  else
5334  {
5335  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5336  nativeLabel = nativeLabelStackBytes;
5337  }
5338 
5339  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5340  nativeLabel[nativeLabelOffset] = 0;
5341  }
5342  else
5343  {
5344  nativeLabel = null;
5345  }
5346 
5347  float vMax = 0.0f;
5348  byte* nativeFormat;
5349  int formatByteCount = 0;
5350  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5351  if (formatByteCount > Util.StackAllocationSizeLimit)
5352  {
5353  nativeFormat = Util.Allocate(formatByteCount + 1);
5354  }
5355  else
5356  {
5357  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5358  nativeFormat = nativeFormatStackBytes;
5359  }
5360 
5361  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5362  nativeFormat[nativeFormatOffset] = 0;
5363  byte* nativeFormatMax = null;
5364  ImGuiSliders flag = 0;
5365  fixed (float* nativeVCurrentMin = &vCurrentMin)
5366  {
5367  fixed (float* nativeVCurrentMax = &vCurrentMax)
5368  {
5369  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5370  if (labelByteCount > Util.StackAllocationSizeLimit)
5371  {
5372  Util.Free(nativeLabel);
5373  }
5374 
5375  if (formatByteCount > Util.StackAllocationSizeLimit)
5376  {
5377  Util.Free(nativeFormat);
5378  }
5379 
5380  return ret != 0;
5381  }
5382  }
5383  }
5384 
5395  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax)
5396  {
5397  byte* nativeLabel;
5398  int labelByteCount = 0;
5399  if (label != null)
5400  {
5401  labelByteCount = Encoding.UTF8.GetByteCount(label);
5402  if (labelByteCount > Util.StackAllocationSizeLimit)
5403  {
5404  nativeLabel = Util.Allocate(labelByteCount + 1);
5405  }
5406  else
5407  {
5408  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5409  nativeLabel = nativeLabelStackBytes;
5410  }
5411 
5412  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5413  nativeLabel[nativeLabelOffset] = 0;
5414  }
5415  else
5416  {
5417  nativeLabel = null;
5418  }
5419 
5420  byte* nativeFormat;
5421  int formatByteCount = 0;
5422  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
5423  if (formatByteCount > Util.StackAllocationSizeLimit)
5424  {
5425  nativeFormat = Util.Allocate(formatByteCount + 1);
5426  }
5427  else
5428  {
5429  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5430  nativeFormat = nativeFormatStackBytes;
5431  }
5432 
5433  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
5434  nativeFormat[nativeFormatOffset] = 0;
5435  byte* nativeFormatMax = null;
5436  ImGuiSliders flag = 0;
5437  fixed (float* nativeVCurrentMin = &vCurrentMin)
5438  {
5439  fixed (float* nativeVCurrentMax = &vCurrentMax)
5440  {
5441  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5442  if (labelByteCount > Util.StackAllocationSizeLimit)
5443  {
5444  Util.Free(nativeLabel);
5445  }
5446 
5447  if (formatByteCount > Util.StackAllocationSizeLimit)
5448  {
5449  Util.Free(nativeFormat);
5450  }
5451 
5452  return ret != 0;
5453  }
5454  }
5455  }
5456 
5468  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format)
5469  {
5470  byte* nativeLabel;
5471  int labelByteCount = 0;
5472  if (label != null)
5473  {
5474  labelByteCount = Encoding.UTF8.GetByteCount(label);
5475  if (labelByteCount > Util.StackAllocationSizeLimit)
5476  {
5477  nativeLabel = Util.Allocate(labelByteCount + 1);
5478  }
5479  else
5480  {
5481  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5482  nativeLabel = nativeLabelStackBytes;
5483  }
5484 
5485  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5486  nativeLabel[nativeLabelOffset] = 0;
5487  }
5488  else
5489  {
5490  nativeLabel = null;
5491  }
5492 
5493  byte* nativeFormat;
5494  int formatByteCount = 0;
5495  if (format != null)
5496  {
5497  formatByteCount = Encoding.UTF8.GetByteCount(format);
5498  if (formatByteCount > Util.StackAllocationSizeLimit)
5499  {
5500  nativeFormat = Util.Allocate(formatByteCount + 1);
5501  }
5502  else
5503  {
5504  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5505  nativeFormat = nativeFormatStackBytes;
5506  }
5507 
5508  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5509  nativeFormat[nativeFormatOffset] = 0;
5510  }
5511  else
5512  {
5513  nativeFormat = null;
5514  }
5515 
5516  byte* nativeFormatMax = null;
5517  ImGuiSliders flag = 0;
5518  fixed (float* nativeVCurrentMin = &vCurrentMin)
5519  {
5520  fixed (float* nativeVCurrentMax = &vCurrentMax)
5521  {
5522  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5523  if (labelByteCount > Util.StackAllocationSizeLimit)
5524  {
5525  Util.Free(nativeLabel);
5526  }
5527 
5528  if (formatByteCount > Util.StackAllocationSizeLimit)
5529  {
5530  Util.Free(nativeFormat);
5531  }
5532 
5533  return ret != 0;
5534  }
5535  }
5536  }
5537 
5550  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax)
5551  {
5552  byte* nativeLabel;
5553  int labelByteCount = 0;
5554  if (label != null)
5555  {
5556  labelByteCount = Encoding.UTF8.GetByteCount(label);
5557  if (labelByteCount > Util.StackAllocationSizeLimit)
5558  {
5559  nativeLabel = Util.Allocate(labelByteCount + 1);
5560  }
5561  else
5562  {
5563  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5564  nativeLabel = nativeLabelStackBytes;
5565  }
5566 
5567  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5568  nativeLabel[nativeLabelOffset] = 0;
5569  }
5570  else
5571  {
5572  nativeLabel = null;
5573  }
5574 
5575  byte* nativeFormat;
5576  int formatByteCount = 0;
5577  if (format != null)
5578  {
5579  formatByteCount = Encoding.UTF8.GetByteCount(format);
5580  if (formatByteCount > Util.StackAllocationSizeLimit)
5581  {
5582  nativeFormat = Util.Allocate(formatByteCount + 1);
5583  }
5584  else
5585  {
5586  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5587  nativeFormat = nativeFormatStackBytes;
5588  }
5589 
5590  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5591  nativeFormat[nativeFormatOffset] = 0;
5592  }
5593  else
5594  {
5595  nativeFormat = null;
5596  }
5597 
5598  byte* nativeFormatMax;
5599  int formatMaxByteCount = 0;
5600  if (formatMax != null)
5601  {
5602  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5603  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5604  {
5605  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
5606  }
5607  else
5608  {
5609  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
5610  nativeFormatMax = nativeFormatMaxStackBytes;
5611  }
5612 
5613  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5614  nativeFormatMax[nativeFormatMaxOffset] = 0;
5615  }
5616  else
5617  {
5618  nativeFormatMax = null;
5619  }
5620 
5621  ImGuiSliders flag = 0;
5622  fixed (float* nativeVCurrentMin = &vCurrentMin)
5623  {
5624  fixed (float* nativeVCurrentMax = &vCurrentMax)
5625  {
5626  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5627  if (labelByteCount > Util.StackAllocationSizeLimit)
5628  {
5629  Util.Free(nativeLabel);
5630  }
5631 
5632  if (formatByteCount > Util.StackAllocationSizeLimit)
5633  {
5634  Util.Free(nativeFormat);
5635  }
5636 
5637  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5638  {
5639  Util.Free(nativeFormatMax);
5640  }
5641 
5642  return ret != 0;
5643  }
5644  }
5645  }
5646 
5660  public static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax, ImGuiSliders flag)
5661  {
5662  byte* nativeLabel;
5663  int labelByteCount = 0;
5664  if (label != null)
5665  {
5666  labelByteCount = Encoding.UTF8.GetByteCount(label);
5667  if (labelByteCount > Util.StackAllocationSizeLimit)
5668  {
5669  nativeLabel = Util.Allocate(labelByteCount + 1);
5670  }
5671  else
5672  {
5673  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5674  nativeLabel = nativeLabelStackBytes;
5675  }
5676 
5677  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5678  nativeLabel[nativeLabelOffset] = 0;
5679  }
5680  else
5681  {
5682  nativeLabel = null;
5683  }
5684 
5685  byte* nativeFormat;
5686  int formatByteCount = 0;
5687  if (format != null)
5688  {
5689  formatByteCount = Encoding.UTF8.GetByteCount(format);
5690  if (formatByteCount > Util.StackAllocationSizeLimit)
5691  {
5692  nativeFormat = Util.Allocate(formatByteCount + 1);
5693  }
5694  else
5695  {
5696  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5697  nativeFormat = nativeFormatStackBytes;
5698  }
5699 
5700  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
5701  nativeFormat[nativeFormatOffset] = 0;
5702  }
5703  else
5704  {
5705  nativeFormat = null;
5706  }
5707 
5708  byte* nativeFormatMax;
5709  int formatMaxByteCount = 0;
5710  if (formatMax != null)
5711  {
5712  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
5713  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5714  {
5715  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
5716  }
5717  else
5718  {
5719  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
5720  nativeFormatMax = nativeFormatMaxStackBytes;
5721  }
5722 
5723  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
5724  nativeFormatMax[nativeFormatMaxOffset] = 0;
5725  }
5726  else
5727  {
5728  nativeFormatMax = null;
5729  }
5730 
5731  fixed (float* nativeVCurrentMin = &vCurrentMin)
5732  {
5733  fixed (float* nativeVCurrentMax = &vCurrentMax)
5734  {
5735  byte ret = ImGuiNative.igDragFloatRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
5736  if (labelByteCount > Util.StackAllocationSizeLimit)
5737  {
5738  Util.Free(nativeLabel);
5739  }
5740 
5741  if (formatByteCount > Util.StackAllocationSizeLimit)
5742  {
5743  Util.Free(nativeFormat);
5744  }
5745 
5746  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
5747  {
5748  Util.Free(nativeFormatMax);
5749  }
5750 
5751  return ret != 0;
5752  }
5753  }
5754  }
5755 
5762  public static bool DragInt(string label, ref int v)
5763  {
5764  byte* nativeLabel;
5765  int labelByteCount = 0;
5766  if (label != null)
5767  {
5768  labelByteCount = Encoding.UTF8.GetByteCount(label);
5769  if (labelByteCount > Util.StackAllocationSizeLimit)
5770  {
5771  nativeLabel = Util.Allocate(labelByteCount + 1);
5772  }
5773  else
5774  {
5775  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5776  nativeLabel = nativeLabelStackBytes;
5777  }
5778 
5779  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5780  nativeLabel[nativeLabelOffset] = 0;
5781  }
5782  else
5783  {
5784  nativeLabel = null;
5785  }
5786 
5787  float vSpeed = 1.0f;
5788  int vMin = 0;
5789  int vMax = 0;
5790  byte* nativeFormat;
5791  int formatByteCount = 0;
5792  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5793  if (formatByteCount > Util.StackAllocationSizeLimit)
5794  {
5795  nativeFormat = Util.Allocate(formatByteCount + 1);
5796  }
5797  else
5798  {
5799  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5800  nativeFormat = nativeFormatStackBytes;
5801  }
5802 
5803  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5804  nativeFormat[nativeFormatOffset] = 0;
5805  ImGuiSliders flag = 0;
5806  fixed (int* nativeV = &v)
5807  {
5808  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5809  if (labelByteCount > Util.StackAllocationSizeLimit)
5810  {
5811  Util.Free(nativeLabel);
5812  }
5813 
5814  if (formatByteCount > Util.StackAllocationSizeLimit)
5815  {
5816  Util.Free(nativeFormat);
5817  }
5818 
5819  return ret != 0;
5820  }
5821  }
5822 
5830  public static bool DragInt(string label, ref int v, float vSpeed)
5831  {
5832  byte* nativeLabel;
5833  int labelByteCount = 0;
5834  if (label != null)
5835  {
5836  labelByteCount = Encoding.UTF8.GetByteCount(label);
5837  if (labelByteCount > Util.StackAllocationSizeLimit)
5838  {
5839  nativeLabel = Util.Allocate(labelByteCount + 1);
5840  }
5841  else
5842  {
5843  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5844  nativeLabel = nativeLabelStackBytes;
5845  }
5846 
5847  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5848  nativeLabel[nativeLabelOffset] = 0;
5849  }
5850  else
5851  {
5852  nativeLabel = null;
5853  }
5854 
5855  int vMin = 0;
5856  int vMax = 0;
5857  byte* nativeFormat;
5858  int formatByteCount = 0;
5859  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5860  if (formatByteCount > Util.StackAllocationSizeLimit)
5861  {
5862  nativeFormat = Util.Allocate(formatByteCount + 1);
5863  }
5864  else
5865  {
5866  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5867  nativeFormat = nativeFormatStackBytes;
5868  }
5869 
5870  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5871  nativeFormat[nativeFormatOffset] = 0;
5872  ImGuiSliders flag = 0;
5873  fixed (int* nativeV = &v)
5874  {
5875  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5876  if (labelByteCount > Util.StackAllocationSizeLimit)
5877  {
5878  Util.Free(nativeLabel);
5879  }
5880 
5881  if (formatByteCount > Util.StackAllocationSizeLimit)
5882  {
5883  Util.Free(nativeFormat);
5884  }
5885 
5886  return ret != 0;
5887  }
5888  }
5889 
5898  public static bool DragInt(string label, ref int v, float vSpeed, int vMin)
5899  {
5900  byte* nativeLabel;
5901  int labelByteCount = 0;
5902  if (label != null)
5903  {
5904  labelByteCount = Encoding.UTF8.GetByteCount(label);
5905  if (labelByteCount > Util.StackAllocationSizeLimit)
5906  {
5907  nativeLabel = Util.Allocate(labelByteCount + 1);
5908  }
5909  else
5910  {
5911  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5912  nativeLabel = nativeLabelStackBytes;
5913  }
5914 
5915  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5916  nativeLabel[nativeLabelOffset] = 0;
5917  }
5918  else
5919  {
5920  nativeLabel = null;
5921  }
5922 
5923  int vMax = 0;
5924  byte* nativeFormat;
5925  int formatByteCount = 0;
5926  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5927  if (formatByteCount > Util.StackAllocationSizeLimit)
5928  {
5929  nativeFormat = Util.Allocate(formatByteCount + 1);
5930  }
5931  else
5932  {
5933  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
5934  nativeFormat = nativeFormatStackBytes;
5935  }
5936 
5937  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
5938  nativeFormat[nativeFormatOffset] = 0;
5939  ImGuiSliders flag = 0;
5940  fixed (int* nativeV = &v)
5941  {
5942  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
5943  if (labelByteCount > Util.StackAllocationSizeLimit)
5944  {
5945  Util.Free(nativeLabel);
5946  }
5947 
5948  if (formatByteCount > Util.StackAllocationSizeLimit)
5949  {
5950  Util.Free(nativeFormat);
5951  }
5952 
5953  return ret != 0;
5954  }
5955  }
5956 
5966  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax)
5967  {
5968  byte* nativeLabel;
5969  int labelByteCount = 0;
5970  if (label != null)
5971  {
5972  labelByteCount = Encoding.UTF8.GetByteCount(label);
5973  if (labelByteCount > Util.StackAllocationSizeLimit)
5974  {
5975  nativeLabel = Util.Allocate(labelByteCount + 1);
5976  }
5977  else
5978  {
5979  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
5980  nativeLabel = nativeLabelStackBytes;
5981  }
5982 
5983  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
5984  nativeLabel[nativeLabelOffset] = 0;
5985  }
5986  else
5987  {
5988  nativeLabel = null;
5989  }
5990 
5991  byte* nativeFormat;
5992  int formatByteCount = 0;
5993  formatByteCount = Encoding.UTF8.GetByteCount("%d");
5994  if (formatByteCount > Util.StackAllocationSizeLimit)
5995  {
5996  nativeFormat = Util.Allocate(formatByteCount + 1);
5997  }
5998  else
5999  {
6000  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6001  nativeFormat = nativeFormatStackBytes;
6002  }
6003 
6004  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6005  nativeFormat[nativeFormatOffset] = 0;
6006  ImGuiSliders flag = 0;
6007  fixed (int* nativeV = &v)
6008  {
6009  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6010  if (labelByteCount > Util.StackAllocationSizeLimit)
6011  {
6012  Util.Free(nativeLabel);
6013  }
6014 
6015  if (formatByteCount > Util.StackAllocationSizeLimit)
6016  {
6017  Util.Free(nativeFormat);
6018  }
6019 
6020  return ret != 0;
6021  }
6022  }
6023 
6034  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6035  {
6036  byte* nativeLabel;
6037  int labelByteCount = 0;
6038  if (label != null)
6039  {
6040  labelByteCount = Encoding.UTF8.GetByteCount(label);
6041  if (labelByteCount > Util.StackAllocationSizeLimit)
6042  {
6043  nativeLabel = Util.Allocate(labelByteCount + 1);
6044  }
6045  else
6046  {
6047  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6048  nativeLabel = nativeLabelStackBytes;
6049  }
6050 
6051  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6052  nativeLabel[nativeLabelOffset] = 0;
6053  }
6054  else
6055  {
6056  nativeLabel = null;
6057  }
6058 
6059  byte* nativeFormat;
6060  int formatByteCount = 0;
6061  if (format != null)
6062  {
6063  formatByteCount = Encoding.UTF8.GetByteCount(format);
6064  if (formatByteCount > Util.StackAllocationSizeLimit)
6065  {
6066  nativeFormat = Util.Allocate(formatByteCount + 1);
6067  }
6068  else
6069  {
6070  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6071  nativeFormat = nativeFormatStackBytes;
6072  }
6073 
6074  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6075  nativeFormat[nativeFormatOffset] = 0;
6076  }
6077  else
6078  {
6079  nativeFormat = null;
6080  }
6081 
6082  ImGuiSliders flag = 0;
6083  fixed (int* nativeV = &v)
6084  {
6085  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6086  if (labelByteCount > Util.StackAllocationSizeLimit)
6087  {
6088  Util.Free(nativeLabel);
6089  }
6090 
6091  if (formatByteCount > Util.StackAllocationSizeLimit)
6092  {
6093  Util.Free(nativeFormat);
6094  }
6095 
6096  return ret != 0;
6097  }
6098  }
6099 
6111  public static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
6112  {
6113  byte* nativeLabel;
6114  int labelByteCount = 0;
6115  if (label != null)
6116  {
6117  labelByteCount = Encoding.UTF8.GetByteCount(label);
6118  if (labelByteCount > Util.StackAllocationSizeLimit)
6119  {
6120  nativeLabel = Util.Allocate(labelByteCount + 1);
6121  }
6122  else
6123  {
6124  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6125  nativeLabel = nativeLabelStackBytes;
6126  }
6127 
6128  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6129  nativeLabel[nativeLabelOffset] = 0;
6130  }
6131  else
6132  {
6133  nativeLabel = null;
6134  }
6135 
6136  byte* nativeFormat;
6137  int formatByteCount = 0;
6138  if (format != null)
6139  {
6140  formatByteCount = Encoding.UTF8.GetByteCount(format);
6141  if (formatByteCount > Util.StackAllocationSizeLimit)
6142  {
6143  nativeFormat = Util.Allocate(formatByteCount + 1);
6144  }
6145  else
6146  {
6147  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6148  nativeFormat = nativeFormatStackBytes;
6149  }
6150 
6151  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6152  nativeFormat[nativeFormatOffset] = 0;
6153  }
6154  else
6155  {
6156  nativeFormat = null;
6157  }
6158 
6159  fixed (int* nativeV = &v)
6160  {
6161  byte ret = ImGuiNative.igDragInt(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6162  if (labelByteCount > Util.StackAllocationSizeLimit)
6163  {
6164  Util.Free(nativeLabel);
6165  }
6166 
6167  if (formatByteCount > Util.StackAllocationSizeLimit)
6168  {
6169  Util.Free(nativeFormat);
6170  }
6171 
6172  return ret != 0;
6173  }
6174  }
6175 
6182  public static bool DragInt2(string label, ref int v)
6183  {
6184  byte* nativeLabel;
6185  int labelByteCount = 0;
6186  if (label != null)
6187  {
6188  labelByteCount = Encoding.UTF8.GetByteCount(label);
6189  if (labelByteCount > Util.StackAllocationSizeLimit)
6190  {
6191  nativeLabel = Util.Allocate(labelByteCount + 1);
6192  }
6193  else
6194  {
6195  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6196  nativeLabel = nativeLabelStackBytes;
6197  }
6198 
6199  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6200  nativeLabel[nativeLabelOffset] = 0;
6201  }
6202  else
6203  {
6204  nativeLabel = null;
6205  }
6206 
6207  float vSpeed = 1.0f;
6208  int vMin = 0;
6209  int vMax = 0;
6210  byte* nativeFormat;
6211  int formatByteCount = 0;
6212  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6213  if (formatByteCount > Util.StackAllocationSizeLimit)
6214  {
6215  nativeFormat = Util.Allocate(formatByteCount + 1);
6216  }
6217  else
6218  {
6219  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6220  nativeFormat = nativeFormatStackBytes;
6221  }
6222 
6223  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6224  nativeFormat[nativeFormatOffset] = 0;
6225  ImGuiSliders flag = 0;
6226  fixed (int* nativeV = &v)
6227  {
6228  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6229  if (labelByteCount > Util.StackAllocationSizeLimit)
6230  {
6231  Util.Free(nativeLabel);
6232  }
6233 
6234  if (formatByteCount > Util.StackAllocationSizeLimit)
6235  {
6236  Util.Free(nativeFormat);
6237  }
6238 
6239  return ret != 0;
6240  }
6241  }
6242 
6250  public static bool DragInt2(string label, ref int v, float vSpeed)
6251  {
6252  byte* nativeLabel;
6253  int labelByteCount = 0;
6254  if (label != null)
6255  {
6256  labelByteCount = Encoding.UTF8.GetByteCount(label);
6257  if (labelByteCount > Util.StackAllocationSizeLimit)
6258  {
6259  nativeLabel = Util.Allocate(labelByteCount + 1);
6260  }
6261  else
6262  {
6263  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6264  nativeLabel = nativeLabelStackBytes;
6265  }
6266 
6267  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6268  nativeLabel[nativeLabelOffset] = 0;
6269  }
6270  else
6271  {
6272  nativeLabel = null;
6273  }
6274 
6275  int vMin = 0;
6276  int vMax = 0;
6277  byte* nativeFormat;
6278  int formatByteCount = 0;
6279  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6280  if (formatByteCount > Util.StackAllocationSizeLimit)
6281  {
6282  nativeFormat = Util.Allocate(formatByteCount + 1);
6283  }
6284  else
6285  {
6286  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6287  nativeFormat = nativeFormatStackBytes;
6288  }
6289 
6290  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6291  nativeFormat[nativeFormatOffset] = 0;
6292  ImGuiSliders flag = 0;
6293  fixed (int* nativeV = &v)
6294  {
6295  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6296  if (labelByteCount > Util.StackAllocationSizeLimit)
6297  {
6298  Util.Free(nativeLabel);
6299  }
6300 
6301  if (formatByteCount > Util.StackAllocationSizeLimit)
6302  {
6303  Util.Free(nativeFormat);
6304  }
6305 
6306  return ret != 0;
6307  }
6308  }
6309 
6318  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin)
6319  {
6320  byte* nativeLabel;
6321  int labelByteCount = 0;
6322  if (label != null)
6323  {
6324  labelByteCount = Encoding.UTF8.GetByteCount(label);
6325  if (labelByteCount > Util.StackAllocationSizeLimit)
6326  {
6327  nativeLabel = Util.Allocate(labelByteCount + 1);
6328  }
6329  else
6330  {
6331  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6332  nativeLabel = nativeLabelStackBytes;
6333  }
6334 
6335  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6336  nativeLabel[nativeLabelOffset] = 0;
6337  }
6338  else
6339  {
6340  nativeLabel = null;
6341  }
6342 
6343  int vMax = 0;
6344  byte* nativeFormat;
6345  int formatByteCount = 0;
6346  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6347  if (formatByteCount > Util.StackAllocationSizeLimit)
6348  {
6349  nativeFormat = Util.Allocate(formatByteCount + 1);
6350  }
6351  else
6352  {
6353  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6354  nativeFormat = nativeFormatStackBytes;
6355  }
6356 
6357  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6358  nativeFormat[nativeFormatOffset] = 0;
6359  ImGuiSliders flag = 0;
6360  fixed (int* nativeV = &v)
6361  {
6362  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6363  if (labelByteCount > Util.StackAllocationSizeLimit)
6364  {
6365  Util.Free(nativeLabel);
6366  }
6367 
6368  if (formatByteCount > Util.StackAllocationSizeLimit)
6369  {
6370  Util.Free(nativeFormat);
6371  }
6372 
6373  return ret != 0;
6374  }
6375  }
6376 
6386  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax)
6387  {
6388  byte* nativeLabel;
6389  int labelByteCount = 0;
6390  if (label != null)
6391  {
6392  labelByteCount = Encoding.UTF8.GetByteCount(label);
6393  if (labelByteCount > Util.StackAllocationSizeLimit)
6394  {
6395  nativeLabel = Util.Allocate(labelByteCount + 1);
6396  }
6397  else
6398  {
6399  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6400  nativeLabel = nativeLabelStackBytes;
6401  }
6402 
6403  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6404  nativeLabel[nativeLabelOffset] = 0;
6405  }
6406  else
6407  {
6408  nativeLabel = null;
6409  }
6410 
6411  byte* nativeFormat;
6412  int formatByteCount = 0;
6413  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6414  if (formatByteCount > Util.StackAllocationSizeLimit)
6415  {
6416  nativeFormat = Util.Allocate(formatByteCount + 1);
6417  }
6418  else
6419  {
6420  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6421  nativeFormat = nativeFormatStackBytes;
6422  }
6423 
6424  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6425  nativeFormat[nativeFormatOffset] = 0;
6426  ImGuiSliders flag = 0;
6427  fixed (int* nativeV = &v)
6428  {
6429  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6430  if (labelByteCount > Util.StackAllocationSizeLimit)
6431  {
6432  Util.Free(nativeLabel);
6433  }
6434 
6435  if (formatByteCount > Util.StackAllocationSizeLimit)
6436  {
6437  Util.Free(nativeFormat);
6438  }
6439 
6440  return ret != 0;
6441  }
6442  }
6443 
6454  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6455  {
6456  byte* nativeLabel;
6457  int labelByteCount = 0;
6458  if (label != null)
6459  {
6460  labelByteCount = Encoding.UTF8.GetByteCount(label);
6461  if (labelByteCount > Util.StackAllocationSizeLimit)
6462  {
6463  nativeLabel = Util.Allocate(labelByteCount + 1);
6464  }
6465  else
6466  {
6467  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6468  nativeLabel = nativeLabelStackBytes;
6469  }
6470 
6471  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6472  nativeLabel[nativeLabelOffset] = 0;
6473  }
6474  else
6475  {
6476  nativeLabel = null;
6477  }
6478 
6479  byte* nativeFormat;
6480  int formatByteCount = 0;
6481  if (format != null)
6482  {
6483  formatByteCount = Encoding.UTF8.GetByteCount(format);
6484  if (formatByteCount > Util.StackAllocationSizeLimit)
6485  {
6486  nativeFormat = Util.Allocate(formatByteCount + 1);
6487  }
6488  else
6489  {
6490  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6491  nativeFormat = nativeFormatStackBytes;
6492  }
6493 
6494  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6495  nativeFormat[nativeFormatOffset] = 0;
6496  }
6497  else
6498  {
6499  nativeFormat = null;
6500  }
6501 
6502  ImGuiSliders flag = 0;
6503  fixed (int* nativeV = &v)
6504  {
6505  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6506  if (labelByteCount > Util.StackAllocationSizeLimit)
6507  {
6508  Util.Free(nativeLabel);
6509  }
6510 
6511  if (formatByteCount > Util.StackAllocationSizeLimit)
6512  {
6513  Util.Free(nativeFormat);
6514  }
6515 
6516  return ret != 0;
6517  }
6518  }
6519 
6531  public static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
6532  {
6533  byte* nativeLabel;
6534  int labelByteCount = 0;
6535  if (label != null)
6536  {
6537  labelByteCount = Encoding.UTF8.GetByteCount(label);
6538  if (labelByteCount > Util.StackAllocationSizeLimit)
6539  {
6540  nativeLabel = Util.Allocate(labelByteCount + 1);
6541  }
6542  else
6543  {
6544  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6545  nativeLabel = nativeLabelStackBytes;
6546  }
6547 
6548  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6549  nativeLabel[nativeLabelOffset] = 0;
6550  }
6551  else
6552  {
6553  nativeLabel = null;
6554  }
6555 
6556  byte* nativeFormat;
6557  int formatByteCount = 0;
6558  if (format != null)
6559  {
6560  formatByteCount = Encoding.UTF8.GetByteCount(format);
6561  if (formatByteCount > Util.StackAllocationSizeLimit)
6562  {
6563  nativeFormat = Util.Allocate(formatByteCount + 1);
6564  }
6565  else
6566  {
6567  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6568  nativeFormat = nativeFormatStackBytes;
6569  }
6570 
6571  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6572  nativeFormat[nativeFormatOffset] = 0;
6573  }
6574  else
6575  {
6576  nativeFormat = null;
6577  }
6578 
6579  fixed (int* nativeV = &v)
6580  {
6581  byte ret = ImGuiNative.igDragInt2(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6582  if (labelByteCount > Util.StackAllocationSizeLimit)
6583  {
6584  Util.Free(nativeLabel);
6585  }
6586 
6587  if (formatByteCount > Util.StackAllocationSizeLimit)
6588  {
6589  Util.Free(nativeFormat);
6590  }
6591 
6592  return ret != 0;
6593  }
6594  }
6595 
6602  public static bool DragInt3(string label, ref int v)
6603  {
6604  byte* nativeLabel;
6605  int labelByteCount = 0;
6606  if (label != null)
6607  {
6608  labelByteCount = Encoding.UTF8.GetByteCount(label);
6609  if (labelByteCount > Util.StackAllocationSizeLimit)
6610  {
6611  nativeLabel = Util.Allocate(labelByteCount + 1);
6612  }
6613  else
6614  {
6615  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6616  nativeLabel = nativeLabelStackBytes;
6617  }
6618 
6619  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6620  nativeLabel[nativeLabelOffset] = 0;
6621  }
6622  else
6623  {
6624  nativeLabel = null;
6625  }
6626 
6627  float vSpeed = 1.0f;
6628  int vMin = 0;
6629  int vMax = 0;
6630  byte* nativeFormat;
6631  int formatByteCount = 0;
6632  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6633  if (formatByteCount > Util.StackAllocationSizeLimit)
6634  {
6635  nativeFormat = Util.Allocate(formatByteCount + 1);
6636  }
6637  else
6638  {
6639  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6640  nativeFormat = nativeFormatStackBytes;
6641  }
6642 
6643  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6644  nativeFormat[nativeFormatOffset] = 0;
6645  ImGuiSliders flag = 0;
6646  fixed (int* nativeV = &v)
6647  {
6648  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6649  if (labelByteCount > Util.StackAllocationSizeLimit)
6650  {
6651  Util.Free(nativeLabel);
6652  }
6653 
6654  if (formatByteCount > Util.StackAllocationSizeLimit)
6655  {
6656  Util.Free(nativeFormat);
6657  }
6658 
6659  return ret != 0;
6660  }
6661  }
6662 
6670  public static bool DragInt3(string label, ref int v, float vSpeed)
6671  {
6672  byte* nativeLabel;
6673  int labelByteCount = 0;
6674  if (label != null)
6675  {
6676  labelByteCount = Encoding.UTF8.GetByteCount(label);
6677  if (labelByteCount > Util.StackAllocationSizeLimit)
6678  {
6679  nativeLabel = Util.Allocate(labelByteCount + 1);
6680  }
6681  else
6682  {
6683  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6684  nativeLabel = nativeLabelStackBytes;
6685  }
6686 
6687  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6688  nativeLabel[nativeLabelOffset] = 0;
6689  }
6690  else
6691  {
6692  nativeLabel = null;
6693  }
6694 
6695  int vMin = 0;
6696  int vMax = 0;
6697  byte* nativeFormat;
6698  int formatByteCount = 0;
6699  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6700  if (formatByteCount > Util.StackAllocationSizeLimit)
6701  {
6702  nativeFormat = Util.Allocate(formatByteCount + 1);
6703  }
6704  else
6705  {
6706  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6707  nativeFormat = nativeFormatStackBytes;
6708  }
6709 
6710  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6711  nativeFormat[nativeFormatOffset] = 0;
6712  ImGuiSliders flag = 0;
6713  fixed (int* nativeV = &v)
6714  {
6715  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6716  if (labelByteCount > Util.StackAllocationSizeLimit)
6717  {
6718  Util.Free(nativeLabel);
6719  }
6720 
6721  if (formatByteCount > Util.StackAllocationSizeLimit)
6722  {
6723  Util.Free(nativeFormat);
6724  }
6725 
6726  return ret != 0;
6727  }
6728  }
6729 
6738  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin)
6739  {
6740  byte* nativeLabel;
6741  int labelByteCount = 0;
6742  if (label != null)
6743  {
6744  labelByteCount = Encoding.UTF8.GetByteCount(label);
6745  if (labelByteCount > Util.StackAllocationSizeLimit)
6746  {
6747  nativeLabel = Util.Allocate(labelByteCount + 1);
6748  }
6749  else
6750  {
6751  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6752  nativeLabel = nativeLabelStackBytes;
6753  }
6754 
6755  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6756  nativeLabel[nativeLabelOffset] = 0;
6757  }
6758  else
6759  {
6760  nativeLabel = null;
6761  }
6762 
6763  int vMax = 0;
6764  byte* nativeFormat;
6765  int formatByteCount = 0;
6766  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6767  if (formatByteCount > Util.StackAllocationSizeLimit)
6768  {
6769  nativeFormat = Util.Allocate(formatByteCount + 1);
6770  }
6771  else
6772  {
6773  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6774  nativeFormat = nativeFormatStackBytes;
6775  }
6776 
6777  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6778  nativeFormat[nativeFormatOffset] = 0;
6779  ImGuiSliders flag = 0;
6780  fixed (int* nativeV = &v)
6781  {
6782  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6783  if (labelByteCount > Util.StackAllocationSizeLimit)
6784  {
6785  Util.Free(nativeLabel);
6786  }
6787 
6788  if (formatByteCount > Util.StackAllocationSizeLimit)
6789  {
6790  Util.Free(nativeFormat);
6791  }
6792 
6793  return ret != 0;
6794  }
6795  }
6796 
6806  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax)
6807  {
6808  byte* nativeLabel;
6809  int labelByteCount = 0;
6810  if (label != null)
6811  {
6812  labelByteCount = Encoding.UTF8.GetByteCount(label);
6813  if (labelByteCount > Util.StackAllocationSizeLimit)
6814  {
6815  nativeLabel = Util.Allocate(labelByteCount + 1);
6816  }
6817  else
6818  {
6819  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6820  nativeLabel = nativeLabelStackBytes;
6821  }
6822 
6823  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6824  nativeLabel[nativeLabelOffset] = 0;
6825  }
6826  else
6827  {
6828  nativeLabel = null;
6829  }
6830 
6831  byte* nativeFormat;
6832  int formatByteCount = 0;
6833  formatByteCount = Encoding.UTF8.GetByteCount("%d");
6834  if (formatByteCount > Util.StackAllocationSizeLimit)
6835  {
6836  nativeFormat = Util.Allocate(formatByteCount + 1);
6837  }
6838  else
6839  {
6840  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6841  nativeFormat = nativeFormatStackBytes;
6842  }
6843 
6844  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
6845  nativeFormat[nativeFormatOffset] = 0;
6846  ImGuiSliders flag = 0;
6847  fixed (int* nativeV = &v)
6848  {
6849  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6850  if (labelByteCount > Util.StackAllocationSizeLimit)
6851  {
6852  Util.Free(nativeLabel);
6853  }
6854 
6855  if (formatByteCount > Util.StackAllocationSizeLimit)
6856  {
6857  Util.Free(nativeFormat);
6858  }
6859 
6860  return ret != 0;
6861  }
6862  }
6863 
6874  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
6875  {
6876  byte* nativeLabel;
6877  int labelByteCount = 0;
6878  if (label != null)
6879  {
6880  labelByteCount = Encoding.UTF8.GetByteCount(label);
6881  if (labelByteCount > Util.StackAllocationSizeLimit)
6882  {
6883  nativeLabel = Util.Allocate(labelByteCount + 1);
6884  }
6885  else
6886  {
6887  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6888  nativeLabel = nativeLabelStackBytes;
6889  }
6890 
6891  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6892  nativeLabel[nativeLabelOffset] = 0;
6893  }
6894  else
6895  {
6896  nativeLabel = null;
6897  }
6898 
6899  byte* nativeFormat;
6900  int formatByteCount = 0;
6901  if (format != null)
6902  {
6903  formatByteCount = Encoding.UTF8.GetByteCount(format);
6904  if (formatByteCount > Util.StackAllocationSizeLimit)
6905  {
6906  nativeFormat = Util.Allocate(formatByteCount + 1);
6907  }
6908  else
6909  {
6910  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6911  nativeFormat = nativeFormatStackBytes;
6912  }
6913 
6914  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6915  nativeFormat[nativeFormatOffset] = 0;
6916  }
6917  else
6918  {
6919  nativeFormat = null;
6920  }
6921 
6922  ImGuiSliders flag = 0;
6923  fixed (int* nativeV = &v)
6924  {
6925  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
6926  if (labelByteCount > Util.StackAllocationSizeLimit)
6927  {
6928  Util.Free(nativeLabel);
6929  }
6930 
6931  if (formatByteCount > Util.StackAllocationSizeLimit)
6932  {
6933  Util.Free(nativeFormat);
6934  }
6935 
6936  return ret != 0;
6937  }
6938  }
6939 
6951  public static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
6952  {
6953  byte* nativeLabel;
6954  int labelByteCount = 0;
6955  if (label != null)
6956  {
6957  labelByteCount = Encoding.UTF8.GetByteCount(label);
6958  if (labelByteCount > Util.StackAllocationSizeLimit)
6959  {
6960  nativeLabel = Util.Allocate(labelByteCount + 1);
6961  }
6962  else
6963  {
6964  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
6965  nativeLabel = nativeLabelStackBytes;
6966  }
6967 
6968  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
6969  nativeLabel[nativeLabelOffset] = 0;
6970  }
6971  else
6972  {
6973  nativeLabel = null;
6974  }
6975 
6976  byte* nativeFormat;
6977  int formatByteCount = 0;
6978  if (format != null)
6979  {
6980  formatByteCount = Encoding.UTF8.GetByteCount(format);
6981  if (formatByteCount > Util.StackAllocationSizeLimit)
6982  {
6983  nativeFormat = Util.Allocate(formatByteCount + 1);
6984  }
6985  else
6986  {
6987  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
6988  nativeFormat = nativeFormatStackBytes;
6989  }
6990 
6991  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
6992  nativeFormat[nativeFormatOffset] = 0;
6993  }
6994  else
6995  {
6996  nativeFormat = null;
6997  }
6998 
6999  fixed (int* nativeV = &v)
7000  {
7001  byte ret = ImGuiNative.igDragInt3(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7002  if (labelByteCount > Util.StackAllocationSizeLimit)
7003  {
7004  Util.Free(nativeLabel);
7005  }
7006 
7007  if (formatByteCount > Util.StackAllocationSizeLimit)
7008  {
7009  Util.Free(nativeFormat);
7010  }
7011 
7012  return ret != 0;
7013  }
7014  }
7015 
7022  public static bool DragInt4(string label, ref int v)
7023  {
7024  byte* nativeLabel;
7025  int labelByteCount = 0;
7026  if (label != null)
7027  {
7028  labelByteCount = Encoding.UTF8.GetByteCount(label);
7029  if (labelByteCount > Util.StackAllocationSizeLimit)
7030  {
7031  nativeLabel = Util.Allocate(labelByteCount + 1);
7032  }
7033  else
7034  {
7035  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7036  nativeLabel = nativeLabelStackBytes;
7037  }
7038 
7039  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7040  nativeLabel[nativeLabelOffset] = 0;
7041  }
7042  else
7043  {
7044  nativeLabel = null;
7045  }
7046 
7047  float vSpeed = 1.0f;
7048  int vMin = 0;
7049  int vMax = 0;
7050  byte* nativeFormat;
7051  int formatByteCount = 0;
7052  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7053  if (formatByteCount > Util.StackAllocationSizeLimit)
7054  {
7055  nativeFormat = Util.Allocate(formatByteCount + 1);
7056  }
7057  else
7058  {
7059  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7060  nativeFormat = nativeFormatStackBytes;
7061  }
7062 
7063  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7064  nativeFormat[nativeFormatOffset] = 0;
7065  ImGuiSliders flag = 0;
7066  fixed (int* nativeV = &v)
7067  {
7068  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7069  if (labelByteCount > Util.StackAllocationSizeLimit)
7070  {
7071  Util.Free(nativeLabel);
7072  }
7073 
7074  if (formatByteCount > Util.StackAllocationSizeLimit)
7075  {
7076  Util.Free(nativeFormat);
7077  }
7078 
7079  return ret != 0;
7080  }
7081  }
7082 
7090  public static bool DragInt4(string label, ref int v, float vSpeed)
7091  {
7092  byte* nativeLabel;
7093  int labelByteCount = 0;
7094  if (label != null)
7095  {
7096  labelByteCount = Encoding.UTF8.GetByteCount(label);
7097  if (labelByteCount > Util.StackAllocationSizeLimit)
7098  {
7099  nativeLabel = Util.Allocate(labelByteCount + 1);
7100  }
7101  else
7102  {
7103  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7104  nativeLabel = nativeLabelStackBytes;
7105  }
7106 
7107  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7108  nativeLabel[nativeLabelOffset] = 0;
7109  }
7110  else
7111  {
7112  nativeLabel = null;
7113  }
7114 
7115  int vMin = 0;
7116  int vMax = 0;
7117  byte* nativeFormat;
7118  int formatByteCount = 0;
7119  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7120  if (formatByteCount > Util.StackAllocationSizeLimit)
7121  {
7122  nativeFormat = Util.Allocate(formatByteCount + 1);
7123  }
7124  else
7125  {
7126  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7127  nativeFormat = nativeFormatStackBytes;
7128  }
7129 
7130  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7131  nativeFormat[nativeFormatOffset] = 0;
7132  ImGuiSliders flag = 0;
7133  fixed (int* nativeV = &v)
7134  {
7135  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7136  if (labelByteCount > Util.StackAllocationSizeLimit)
7137  {
7138  Util.Free(nativeLabel);
7139  }
7140 
7141  if (formatByteCount > Util.StackAllocationSizeLimit)
7142  {
7143  Util.Free(nativeFormat);
7144  }
7145 
7146  return ret != 0;
7147  }
7148  }
7149 
7158  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin)
7159  {
7160  byte* nativeLabel;
7161  int labelByteCount = 0;
7162  if (label != null)
7163  {
7164  labelByteCount = Encoding.UTF8.GetByteCount(label);
7165  if (labelByteCount > Util.StackAllocationSizeLimit)
7166  {
7167  nativeLabel = Util.Allocate(labelByteCount + 1);
7168  }
7169  else
7170  {
7171  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7172  nativeLabel = nativeLabelStackBytes;
7173  }
7174 
7175  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7176  nativeLabel[nativeLabelOffset] = 0;
7177  }
7178  else
7179  {
7180  nativeLabel = null;
7181  }
7182 
7183  int vMax = 0;
7184  byte* nativeFormat;
7185  int formatByteCount = 0;
7186  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7187  if (formatByteCount > Util.StackAllocationSizeLimit)
7188  {
7189  nativeFormat = Util.Allocate(formatByteCount + 1);
7190  }
7191  else
7192  {
7193  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7194  nativeFormat = nativeFormatStackBytes;
7195  }
7196 
7197  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7198  nativeFormat[nativeFormatOffset] = 0;
7199  ImGuiSliders flag = 0;
7200  fixed (int* nativeV = &v)
7201  {
7202  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7203  if (labelByteCount > Util.StackAllocationSizeLimit)
7204  {
7205  Util.Free(nativeLabel);
7206  }
7207 
7208  if (formatByteCount > Util.StackAllocationSizeLimit)
7209  {
7210  Util.Free(nativeFormat);
7211  }
7212 
7213  return ret != 0;
7214  }
7215  }
7216 
7226  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax)
7227  {
7228  byte* nativeLabel;
7229  int labelByteCount = 0;
7230  if (label != null)
7231  {
7232  labelByteCount = Encoding.UTF8.GetByteCount(label);
7233  if (labelByteCount > Util.StackAllocationSizeLimit)
7234  {
7235  nativeLabel = Util.Allocate(labelByteCount + 1);
7236  }
7237  else
7238  {
7239  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7240  nativeLabel = nativeLabelStackBytes;
7241  }
7242 
7243  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7244  nativeLabel[nativeLabelOffset] = 0;
7245  }
7246  else
7247  {
7248  nativeLabel = null;
7249  }
7250 
7251  byte* nativeFormat;
7252  int formatByteCount = 0;
7253  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7254  if (formatByteCount > Util.StackAllocationSizeLimit)
7255  {
7256  nativeFormat = Util.Allocate(formatByteCount + 1);
7257  }
7258  else
7259  {
7260  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7261  nativeFormat = nativeFormatStackBytes;
7262  }
7263 
7264  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7265  nativeFormat[nativeFormatOffset] = 0;
7266  ImGuiSliders flag = 0;
7267  fixed (int* nativeV = &v)
7268  {
7269  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7270  if (labelByteCount > Util.StackAllocationSizeLimit)
7271  {
7272  Util.Free(nativeLabel);
7273  }
7274 
7275  if (formatByteCount > Util.StackAllocationSizeLimit)
7276  {
7277  Util.Free(nativeFormat);
7278  }
7279 
7280  return ret != 0;
7281  }
7282  }
7283 
7294  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
7295  {
7296  byte* nativeLabel;
7297  int labelByteCount = 0;
7298  if (label != null)
7299  {
7300  labelByteCount = Encoding.UTF8.GetByteCount(label);
7301  if (labelByteCount > Util.StackAllocationSizeLimit)
7302  {
7303  nativeLabel = Util.Allocate(labelByteCount + 1);
7304  }
7305  else
7306  {
7307  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7308  nativeLabel = nativeLabelStackBytes;
7309  }
7310 
7311  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7312  nativeLabel[nativeLabelOffset] = 0;
7313  }
7314  else
7315  {
7316  nativeLabel = null;
7317  }
7318 
7319  byte* nativeFormat;
7320  int formatByteCount = 0;
7321  if (format != null)
7322  {
7323  formatByteCount = Encoding.UTF8.GetByteCount(format);
7324  if (formatByteCount > Util.StackAllocationSizeLimit)
7325  {
7326  nativeFormat = Util.Allocate(formatByteCount + 1);
7327  }
7328  else
7329  {
7330  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7331  nativeFormat = nativeFormatStackBytes;
7332  }
7333 
7334  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7335  nativeFormat[nativeFormatOffset] = 0;
7336  }
7337  else
7338  {
7339  nativeFormat = null;
7340  }
7341 
7342  ImGuiSliders flag = 0;
7343  fixed (int* nativeV = &v)
7344  {
7345  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7346  if (labelByteCount > Util.StackAllocationSizeLimit)
7347  {
7348  Util.Free(nativeLabel);
7349  }
7350 
7351  if (formatByteCount > Util.StackAllocationSizeLimit)
7352  {
7353  Util.Free(nativeFormat);
7354  }
7355 
7356  return ret != 0;
7357  }
7358  }
7359 
7371  public static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
7372  {
7373  byte* nativeLabel;
7374  int labelByteCount = 0;
7375  if (label != null)
7376  {
7377  labelByteCount = Encoding.UTF8.GetByteCount(label);
7378  if (labelByteCount > Util.StackAllocationSizeLimit)
7379  {
7380  nativeLabel = Util.Allocate(labelByteCount + 1);
7381  }
7382  else
7383  {
7384  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7385  nativeLabel = nativeLabelStackBytes;
7386  }
7387 
7388  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7389  nativeLabel[nativeLabelOffset] = 0;
7390  }
7391  else
7392  {
7393  nativeLabel = null;
7394  }
7395 
7396  byte* nativeFormat;
7397  int formatByteCount = 0;
7398  if (format != null)
7399  {
7400  formatByteCount = Encoding.UTF8.GetByteCount(format);
7401  if (formatByteCount > Util.StackAllocationSizeLimit)
7402  {
7403  nativeFormat = Util.Allocate(formatByteCount + 1);
7404  }
7405  else
7406  {
7407  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7408  nativeFormat = nativeFormatStackBytes;
7409  }
7410 
7411  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7412  nativeFormat[nativeFormatOffset] = 0;
7413  }
7414  else
7415  {
7416  nativeFormat = null;
7417  }
7418 
7419  fixed (int* nativeV = &v)
7420  {
7421  byte ret = ImGuiNative.igDragInt4(nativeLabel, nativeV, vSpeed, vMin, vMax, nativeFormat, flag);
7422  if (labelByteCount > Util.StackAllocationSizeLimit)
7423  {
7424  Util.Free(nativeLabel);
7425  }
7426 
7427  if (formatByteCount > Util.StackAllocationSizeLimit)
7428  {
7429  Util.Free(nativeFormat);
7430  }
7431 
7432  return ret != 0;
7433  }
7434  }
7435 
7443  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax)
7444  {
7445  byte* nativeLabel;
7446  int labelByteCount = 0;
7447  if (label != null)
7448  {
7449  labelByteCount = Encoding.UTF8.GetByteCount(label);
7450  if (labelByteCount > Util.StackAllocationSizeLimit)
7451  {
7452  nativeLabel = Util.Allocate(labelByteCount + 1);
7453  }
7454  else
7455  {
7456  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7457  nativeLabel = nativeLabelStackBytes;
7458  }
7459 
7460  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7461  nativeLabel[nativeLabelOffset] = 0;
7462  }
7463  else
7464  {
7465  nativeLabel = null;
7466  }
7467 
7468  float vSpeed = 1.0f;
7469  int vMin = 0;
7470  int vMax = 0;
7471  byte* nativeFormat;
7472  int formatByteCount = 0;
7473  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7474  if (formatByteCount > Util.StackAllocationSizeLimit)
7475  {
7476  nativeFormat = Util.Allocate(formatByteCount + 1);
7477  }
7478  else
7479  {
7480  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7481  nativeFormat = nativeFormatStackBytes;
7482  }
7483 
7484  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7485  nativeFormat[nativeFormatOffset] = 0;
7486  byte* nativeFormatMax = null;
7487  ImGuiSliders flag = 0;
7488  fixed (int* nativeVCurrentMin = &vCurrentMin)
7489  {
7490  fixed (int* nativeVCurrentMax = &vCurrentMax)
7491  {
7492  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7493  if (labelByteCount > Util.StackAllocationSizeLimit)
7494  {
7495  Util.Free(nativeLabel);
7496  }
7497 
7498  if (formatByteCount > Util.StackAllocationSizeLimit)
7499  {
7500  Util.Free(nativeFormat);
7501  }
7502 
7503  return ret != 0;
7504  }
7505  }
7506  }
7507 
7516  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed)
7517  {
7518  byte* nativeLabel;
7519  int labelByteCount = 0;
7520  if (label != null)
7521  {
7522  labelByteCount = Encoding.UTF8.GetByteCount(label);
7523  if (labelByteCount > Util.StackAllocationSizeLimit)
7524  {
7525  nativeLabel = Util.Allocate(labelByteCount + 1);
7526  }
7527  else
7528  {
7529  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7530  nativeLabel = nativeLabelStackBytes;
7531  }
7532 
7533  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7534  nativeLabel[nativeLabelOffset] = 0;
7535  }
7536  else
7537  {
7538  nativeLabel = null;
7539  }
7540 
7541  int vMin = 0;
7542  int vMax = 0;
7543  byte* nativeFormat;
7544  int formatByteCount = 0;
7545  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7546  if (formatByteCount > Util.StackAllocationSizeLimit)
7547  {
7548  nativeFormat = Util.Allocate(formatByteCount + 1);
7549  }
7550  else
7551  {
7552  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7553  nativeFormat = nativeFormatStackBytes;
7554  }
7555 
7556  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7557  nativeFormat[nativeFormatOffset] = 0;
7558  byte* nativeFormatMax = null;
7559  ImGuiSliders flag = 0;
7560  fixed (int* nativeVCurrentMin = &vCurrentMin)
7561  {
7562  fixed (int* nativeVCurrentMax = &vCurrentMax)
7563  {
7564  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7565  if (labelByteCount > Util.StackAllocationSizeLimit)
7566  {
7567  Util.Free(nativeLabel);
7568  }
7569 
7570  if (formatByteCount > Util.StackAllocationSizeLimit)
7571  {
7572  Util.Free(nativeFormat);
7573  }
7574 
7575  return ret != 0;
7576  }
7577  }
7578  }
7579 
7589  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin)
7590  {
7591  byte* nativeLabel;
7592  int labelByteCount = 0;
7593  if (label != null)
7594  {
7595  labelByteCount = Encoding.UTF8.GetByteCount(label);
7596  if (labelByteCount > Util.StackAllocationSizeLimit)
7597  {
7598  nativeLabel = Util.Allocate(labelByteCount + 1);
7599  }
7600  else
7601  {
7602  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7603  nativeLabel = nativeLabelStackBytes;
7604  }
7605 
7606  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7607  nativeLabel[nativeLabelOffset] = 0;
7608  }
7609  else
7610  {
7611  nativeLabel = null;
7612  }
7613 
7614  int vMax = 0;
7615  byte* nativeFormat;
7616  int formatByteCount = 0;
7617  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7618  if (formatByteCount > Util.StackAllocationSizeLimit)
7619  {
7620  nativeFormat = Util.Allocate(formatByteCount + 1);
7621  }
7622  else
7623  {
7624  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7625  nativeFormat = nativeFormatStackBytes;
7626  }
7627 
7628  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7629  nativeFormat[nativeFormatOffset] = 0;
7630  byte* nativeFormatMax = null;
7631  ImGuiSliders flag = 0;
7632  fixed (int* nativeVCurrentMin = &vCurrentMin)
7633  {
7634  fixed (int* nativeVCurrentMax = &vCurrentMax)
7635  {
7636  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7637  if (labelByteCount > Util.StackAllocationSizeLimit)
7638  {
7639  Util.Free(nativeLabel);
7640  }
7641 
7642  if (formatByteCount > Util.StackAllocationSizeLimit)
7643  {
7644  Util.Free(nativeFormat);
7645  }
7646 
7647  return ret != 0;
7648  }
7649  }
7650  }
7651 
7662  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax)
7663  {
7664  byte* nativeLabel;
7665  int labelByteCount = 0;
7666  if (label != null)
7667  {
7668  labelByteCount = Encoding.UTF8.GetByteCount(label);
7669  if (labelByteCount > Util.StackAllocationSizeLimit)
7670  {
7671  nativeLabel = Util.Allocate(labelByteCount + 1);
7672  }
7673  else
7674  {
7675  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7676  nativeLabel = nativeLabelStackBytes;
7677  }
7678 
7679  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7680  nativeLabel[nativeLabelOffset] = 0;
7681  }
7682  else
7683  {
7684  nativeLabel = null;
7685  }
7686 
7687  byte* nativeFormat;
7688  int formatByteCount = 0;
7689  formatByteCount = Encoding.UTF8.GetByteCount("%d");
7690  if (formatByteCount > Util.StackAllocationSizeLimit)
7691  {
7692  nativeFormat = Util.Allocate(formatByteCount + 1);
7693  }
7694  else
7695  {
7696  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7697  nativeFormat = nativeFormatStackBytes;
7698  }
7699 
7700  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
7701  nativeFormat[nativeFormatOffset] = 0;
7702  byte* nativeFormatMax = null;
7703  ImGuiSliders flag = 0;
7704  fixed (int* nativeVCurrentMin = &vCurrentMin)
7705  {
7706  fixed (int* nativeVCurrentMax = &vCurrentMax)
7707  {
7708  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7709  if (labelByteCount > Util.StackAllocationSizeLimit)
7710  {
7711  Util.Free(nativeLabel);
7712  }
7713 
7714  if (formatByteCount > Util.StackAllocationSizeLimit)
7715  {
7716  Util.Free(nativeFormat);
7717  }
7718 
7719  return ret != 0;
7720  }
7721  }
7722  }
7723 
7735  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format)
7736  {
7737  byte* nativeLabel;
7738  int labelByteCount = 0;
7739  if (label != null)
7740  {
7741  labelByteCount = Encoding.UTF8.GetByteCount(label);
7742  if (labelByteCount > Util.StackAllocationSizeLimit)
7743  {
7744  nativeLabel = Util.Allocate(labelByteCount + 1);
7745  }
7746  else
7747  {
7748  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7749  nativeLabel = nativeLabelStackBytes;
7750  }
7751 
7752  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7753  nativeLabel[nativeLabelOffset] = 0;
7754  }
7755  else
7756  {
7757  nativeLabel = null;
7758  }
7759 
7760  byte* nativeFormat;
7761  int formatByteCount = 0;
7762  if (format != null)
7763  {
7764  formatByteCount = Encoding.UTF8.GetByteCount(format);
7765  if (formatByteCount > Util.StackAllocationSizeLimit)
7766  {
7767  nativeFormat = Util.Allocate(formatByteCount + 1);
7768  }
7769  else
7770  {
7771  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7772  nativeFormat = nativeFormatStackBytes;
7773  }
7774 
7775  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7776  nativeFormat[nativeFormatOffset] = 0;
7777  }
7778  else
7779  {
7780  nativeFormat = null;
7781  }
7782 
7783  byte* nativeFormatMax = null;
7784  ImGuiSliders flag = 0;
7785  fixed (int* nativeVCurrentMin = &vCurrentMin)
7786  {
7787  fixed (int* nativeVCurrentMax = &vCurrentMax)
7788  {
7789  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7790  if (labelByteCount > Util.StackAllocationSizeLimit)
7791  {
7792  Util.Free(nativeLabel);
7793  }
7794 
7795  if (formatByteCount > Util.StackAllocationSizeLimit)
7796  {
7797  Util.Free(nativeFormat);
7798  }
7799 
7800  return ret != 0;
7801  }
7802  }
7803  }
7804 
7817  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax)
7818  {
7819  byte* nativeLabel;
7820  int labelByteCount = 0;
7821  if (label != null)
7822  {
7823  labelByteCount = Encoding.UTF8.GetByteCount(label);
7824  if (labelByteCount > Util.StackAllocationSizeLimit)
7825  {
7826  nativeLabel = Util.Allocate(labelByteCount + 1);
7827  }
7828  else
7829  {
7830  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7831  nativeLabel = nativeLabelStackBytes;
7832  }
7833 
7834  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7835  nativeLabel[nativeLabelOffset] = 0;
7836  }
7837  else
7838  {
7839  nativeLabel = null;
7840  }
7841 
7842  byte* nativeFormat;
7843  int formatByteCount = 0;
7844  if (format != null)
7845  {
7846  formatByteCount = Encoding.UTF8.GetByteCount(format);
7847  if (formatByteCount > Util.StackAllocationSizeLimit)
7848  {
7849  nativeFormat = Util.Allocate(formatByteCount + 1);
7850  }
7851  else
7852  {
7853  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7854  nativeFormat = nativeFormatStackBytes;
7855  }
7856 
7857  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7858  nativeFormat[nativeFormatOffset] = 0;
7859  }
7860  else
7861  {
7862  nativeFormat = null;
7863  }
7864 
7865  byte* nativeFormatMax;
7866  int formatMaxByteCount = 0;
7867  if (formatMax != null)
7868  {
7869  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7870  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7871  {
7872  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
7873  }
7874  else
7875  {
7876  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
7877  nativeFormatMax = nativeFormatMaxStackBytes;
7878  }
7879 
7880  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7881  nativeFormatMax[nativeFormatMaxOffset] = 0;
7882  }
7883  else
7884  {
7885  nativeFormatMax = null;
7886  }
7887 
7888  ImGuiSliders flag = 0;
7889  fixed (int* nativeVCurrentMin = &vCurrentMin)
7890  {
7891  fixed (int* nativeVCurrentMax = &vCurrentMax)
7892  {
7893  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
7894  if (labelByteCount > Util.StackAllocationSizeLimit)
7895  {
7896  Util.Free(nativeLabel);
7897  }
7898 
7899  if (formatByteCount > Util.StackAllocationSizeLimit)
7900  {
7901  Util.Free(nativeFormat);
7902  }
7903 
7904  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7905  {
7906  Util.Free(nativeFormatMax);
7907  }
7908 
7909  return ret != 0;
7910  }
7911  }
7912  }
7913 
7927  public static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax, ImGuiSliders flag)
7928  {
7929  byte* nativeLabel;
7930  int labelByteCount = 0;
7931  if (label != null)
7932  {
7933  labelByteCount = Encoding.UTF8.GetByteCount(label);
7934  if (labelByteCount > Util.StackAllocationSizeLimit)
7935  {
7936  nativeLabel = Util.Allocate(labelByteCount + 1);
7937  }
7938  else
7939  {
7940  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
7941  nativeLabel = nativeLabelStackBytes;
7942  }
7943 
7944  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
7945  nativeLabel[nativeLabelOffset] = 0;
7946  }
7947  else
7948  {
7949  nativeLabel = null;
7950  }
7951 
7952  byte* nativeFormat;
7953  int formatByteCount = 0;
7954  if (format != null)
7955  {
7956  formatByteCount = Encoding.UTF8.GetByteCount(format);
7957  if (formatByteCount > Util.StackAllocationSizeLimit)
7958  {
7959  nativeFormat = Util.Allocate(formatByteCount + 1);
7960  }
7961  else
7962  {
7963  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
7964  nativeFormat = nativeFormatStackBytes;
7965  }
7966 
7967  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
7968  nativeFormat[nativeFormatOffset] = 0;
7969  }
7970  else
7971  {
7972  nativeFormat = null;
7973  }
7974 
7975  byte* nativeFormatMax;
7976  int formatMaxByteCount = 0;
7977  if (formatMax != null)
7978  {
7979  formatMaxByteCount = Encoding.UTF8.GetByteCount(formatMax);
7980  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
7981  {
7982  nativeFormatMax = Util.Allocate(formatMaxByteCount + 1);
7983  }
7984  else
7985  {
7986  byte* nativeFormatMaxStackBytes = stackalloc byte[formatMaxByteCount + 1];
7987  nativeFormatMax = nativeFormatMaxStackBytes;
7988  }
7989 
7990  int nativeFormatMaxOffset = Util.GetUtf8(formatMax, nativeFormatMax, formatMaxByteCount);
7991  nativeFormatMax[nativeFormatMaxOffset] = 0;
7992  }
7993  else
7994  {
7995  nativeFormatMax = null;
7996  }
7997 
7998  fixed (int* nativeVCurrentMin = &vCurrentMin)
7999  {
8000  fixed (int* nativeVCurrentMax = &vCurrentMax)
8001  {
8002  byte ret = ImGuiNative.igDragIntRange2(nativeLabel, nativeVCurrentMin, nativeVCurrentMax, vSpeed, vMin, vMax, nativeFormat, nativeFormatMax, flag);
8003  if (labelByteCount > Util.StackAllocationSizeLimit)
8004  {
8005  Util.Free(nativeLabel);
8006  }
8007 
8008  if (formatByteCount > Util.StackAllocationSizeLimit)
8009  {
8010  Util.Free(nativeFormat);
8011  }
8012 
8013  if (formatMaxByteCount > Util.StackAllocationSizeLimit)
8014  {
8015  Util.Free(nativeFormatMax);
8016  }
8017 
8018  return ret != 0;
8019  }
8020  }
8021  }
8022 
8030  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData)
8031  {
8032  byte* nativeLabel;
8033  int labelByteCount = 0;
8034  if (label != null)
8035  {
8036  labelByteCount = Encoding.UTF8.GetByteCount(label);
8037  if (labelByteCount > Util.StackAllocationSizeLimit)
8038  {
8039  nativeLabel = Util.Allocate(labelByteCount + 1);
8040  }
8041  else
8042  {
8043  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8044  nativeLabel = nativeLabelStackBytes;
8045  }
8046 
8047  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8048  nativeLabel[nativeLabelOffset] = 0;
8049  }
8050  else
8051  {
8052  nativeLabel = null;
8053  }
8054 
8055  void* nativePData = pData.ToPointer();
8056  float vSpeed = 1.0f;
8057  void* pMin = null;
8058  void* pMax = null;
8059  byte* nativeFormat = null;
8060  ImGuiSliders flag = 0;
8061  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flag);
8062  if (labelByteCount > Util.StackAllocationSizeLimit)
8063  {
8064  Util.Free(nativeLabel);
8065  }
8066 
8067  return ret != 0;
8068  }
8069 
8078  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed)
8079  {
8080  byte* nativeLabel;
8081  int labelByteCount = 0;
8082  if (label != null)
8083  {
8084  labelByteCount = Encoding.UTF8.GetByteCount(label);
8085  if (labelByteCount > Util.StackAllocationSizeLimit)
8086  {
8087  nativeLabel = Util.Allocate(labelByteCount + 1);
8088  }
8089  else
8090  {
8091  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8092  nativeLabel = nativeLabelStackBytes;
8093  }
8094 
8095  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8096  nativeLabel[nativeLabelOffset] = 0;
8097  }
8098  else
8099  {
8100  nativeLabel = null;
8101  }
8102 
8103  void* nativePData = pData.ToPointer();
8104  void* pMin = null;
8105  void* pMax = null;
8106  byte* nativeFormat = null;
8107  ImGuiSliders flag = 0;
8108  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, pMin, pMax, nativeFormat, flag);
8109  if (labelByteCount > Util.StackAllocationSizeLimit)
8110  {
8111  Util.Free(nativeLabel);
8112  }
8113 
8114  return ret != 0;
8115  }
8116 
8126  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin)
8127  {
8128  byte* nativeLabel;
8129  int labelByteCount = 0;
8130  if (label != null)
8131  {
8132  labelByteCount = Encoding.UTF8.GetByteCount(label);
8133  if (labelByteCount > Util.StackAllocationSizeLimit)
8134  {
8135  nativeLabel = Util.Allocate(labelByteCount + 1);
8136  }
8137  else
8138  {
8139  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8140  nativeLabel = nativeLabelStackBytes;
8141  }
8142 
8143  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8144  nativeLabel[nativeLabelOffset] = 0;
8145  }
8146  else
8147  {
8148  nativeLabel = null;
8149  }
8150 
8151  void* nativePData = pData.ToPointer();
8152  void* nativePMin = pMin.ToPointer();
8153  void* pMax = null;
8154  byte* nativeFormat = null;
8155  ImGuiSliders flag = 0;
8156  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, pMax, nativeFormat, flag);
8157  if (labelByteCount > Util.StackAllocationSizeLimit)
8158  {
8159  Util.Free(nativeLabel);
8160  }
8161 
8162  return ret != 0;
8163  }
8164 
8175  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax)
8176  {
8177  byte* nativeLabel;
8178  int labelByteCount = 0;
8179  if (label != null)
8180  {
8181  labelByteCount = Encoding.UTF8.GetByteCount(label);
8182  if (labelByteCount > Util.StackAllocationSizeLimit)
8183  {
8184  nativeLabel = Util.Allocate(labelByteCount + 1);
8185  }
8186  else
8187  {
8188  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8189  nativeLabel = nativeLabelStackBytes;
8190  }
8191 
8192  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8193  nativeLabel[nativeLabelOffset] = 0;
8194  }
8195  else
8196  {
8197  nativeLabel = null;
8198  }
8199 
8200  void* nativePData = pData.ToPointer();
8201  void* nativePMin = pMin.ToPointer();
8202  void* nativePMax = pMax.ToPointer();
8203  byte* nativeFormat = null;
8204  ImGuiSliders flag = 0;
8205  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8206  if (labelByteCount > Util.StackAllocationSizeLimit)
8207  {
8208  Util.Free(nativeLabel);
8209  }
8210 
8211  return ret != 0;
8212  }
8213 
8225  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
8226  {
8227  byte* nativeLabel;
8228  int labelByteCount = 0;
8229  if (label != null)
8230  {
8231  labelByteCount = Encoding.UTF8.GetByteCount(label);
8232  if (labelByteCount > Util.StackAllocationSizeLimit)
8233  {
8234  nativeLabel = Util.Allocate(labelByteCount + 1);
8235  }
8236  else
8237  {
8238  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8239  nativeLabel = nativeLabelStackBytes;
8240  }
8241 
8242  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8243  nativeLabel[nativeLabelOffset] = 0;
8244  }
8245  else
8246  {
8247  nativeLabel = null;
8248  }
8249 
8250  void* nativePData = pData.ToPointer();
8251  void* nativePMin = pMin.ToPointer();
8252  void* nativePMax = pMax.ToPointer();
8253  byte* nativeFormat;
8254  int formatByteCount = 0;
8255  if (format != null)
8256  {
8257  formatByteCount = Encoding.UTF8.GetByteCount(format);
8258  if (formatByteCount > Util.StackAllocationSizeLimit)
8259  {
8260  nativeFormat = Util.Allocate(formatByteCount + 1);
8261  }
8262  else
8263  {
8264  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8265  nativeFormat = nativeFormatStackBytes;
8266  }
8267 
8268  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8269  nativeFormat[nativeFormatOffset] = 0;
8270  }
8271  else
8272  {
8273  nativeFormat = null;
8274  }
8275 
8276  ImGuiSliders flag = 0;
8277  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8278  if (labelByteCount > Util.StackAllocationSizeLimit)
8279  {
8280  Util.Free(nativeLabel);
8281  }
8282 
8283  if (formatByteCount > Util.StackAllocationSizeLimit)
8284  {
8285  Util.Free(nativeFormat);
8286  }
8287 
8288  return ret != 0;
8289  }
8290 
8303  public static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
8304  {
8305  byte* nativeLabel;
8306  int labelByteCount = 0;
8307  if (label != null)
8308  {
8309  labelByteCount = Encoding.UTF8.GetByteCount(label);
8310  if (labelByteCount > Util.StackAllocationSizeLimit)
8311  {
8312  nativeLabel = Util.Allocate(labelByteCount + 1);
8313  }
8314  else
8315  {
8316  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8317  nativeLabel = nativeLabelStackBytes;
8318  }
8319 
8320  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8321  nativeLabel[nativeLabelOffset] = 0;
8322  }
8323  else
8324  {
8325  nativeLabel = null;
8326  }
8327 
8328  void* nativePData = pData.ToPointer();
8329  void* nativePMin = pMin.ToPointer();
8330  void* nativePMax = pMax.ToPointer();
8331  byte* nativeFormat;
8332  int formatByteCount = 0;
8333  if (format != null)
8334  {
8335  formatByteCount = Encoding.UTF8.GetByteCount(format);
8336  if (formatByteCount > Util.StackAllocationSizeLimit)
8337  {
8338  nativeFormat = Util.Allocate(formatByteCount + 1);
8339  }
8340  else
8341  {
8342  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8343  nativeFormat = nativeFormatStackBytes;
8344  }
8345 
8346  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8347  nativeFormat[nativeFormatOffset] = 0;
8348  }
8349  else
8350  {
8351  nativeFormat = null;
8352  }
8353 
8354  byte ret = ImGuiNative.igDragScalar(nativeLabel, dataType, nativePData, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8355  if (labelByteCount > Util.StackAllocationSizeLimit)
8356  {
8357  Util.Free(nativeLabel);
8358  }
8359 
8360  if (formatByteCount > Util.StackAllocationSizeLimit)
8361  {
8362  Util.Free(nativeFormat);
8363  }
8364 
8365  return ret != 0;
8366  }
8367 
8376  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
8377  {
8378  byte* nativeLabel;
8379  int labelByteCount = 0;
8380  if (label != null)
8381  {
8382  labelByteCount = Encoding.UTF8.GetByteCount(label);
8383  if (labelByteCount > Util.StackAllocationSizeLimit)
8384  {
8385  nativeLabel = Util.Allocate(labelByteCount + 1);
8386  }
8387  else
8388  {
8389  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8390  nativeLabel = nativeLabelStackBytes;
8391  }
8392 
8393  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8394  nativeLabel[nativeLabelOffset] = 0;
8395  }
8396  else
8397  {
8398  nativeLabel = null;
8399  }
8400 
8401  void* nativePData = pData.ToPointer();
8402  float vSpeed = 1.0f;
8403  void* pMin = null;
8404  void* pMax = null;
8405  byte* nativeFormat = null;
8406  ImGuiSliders flag = 0;
8407  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flag);
8408  if (labelByteCount > Util.StackAllocationSizeLimit)
8409  {
8410  Util.Free(nativeLabel);
8411  }
8412 
8413  return ret != 0;
8414  }
8415 
8425  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed)
8426  {
8427  byte* nativeLabel;
8428  int labelByteCount = 0;
8429  if (label != null)
8430  {
8431  labelByteCount = Encoding.UTF8.GetByteCount(label);
8432  if (labelByteCount > Util.StackAllocationSizeLimit)
8433  {
8434  nativeLabel = Util.Allocate(labelByteCount + 1);
8435  }
8436  else
8437  {
8438  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8439  nativeLabel = nativeLabelStackBytes;
8440  }
8441 
8442  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8443  nativeLabel[nativeLabelOffset] = 0;
8444  }
8445  else
8446  {
8447  nativeLabel = null;
8448  }
8449 
8450  void* nativePData = pData.ToPointer();
8451  void* pMin = null;
8452  void* pMax = null;
8453  byte* nativeFormat = null;
8454  ImGuiSliders flag = 0;
8455  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, pMin, pMax, nativeFormat, flag);
8456  if (labelByteCount > Util.StackAllocationSizeLimit)
8457  {
8458  Util.Free(nativeLabel);
8459  }
8460 
8461  return ret != 0;
8462  }
8463 
8474  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin)
8475  {
8476  byte* nativeLabel;
8477  int labelByteCount = 0;
8478  if (label != null)
8479  {
8480  labelByteCount = Encoding.UTF8.GetByteCount(label);
8481  if (labelByteCount > Util.StackAllocationSizeLimit)
8482  {
8483  nativeLabel = Util.Allocate(labelByteCount + 1);
8484  }
8485  else
8486  {
8487  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8488  nativeLabel = nativeLabelStackBytes;
8489  }
8490 
8491  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8492  nativeLabel[nativeLabelOffset] = 0;
8493  }
8494  else
8495  {
8496  nativeLabel = null;
8497  }
8498 
8499  void* nativePData = pData.ToPointer();
8500  void* nativePMin = pMin.ToPointer();
8501  void* pMax = null;
8502  byte* nativeFormat = null;
8503  ImGuiSliders flag = 0;
8504  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, pMax, nativeFormat, flag);
8505  if (labelByteCount > Util.StackAllocationSizeLimit)
8506  {
8507  Util.Free(nativeLabel);
8508  }
8509 
8510  return ret != 0;
8511  }
8512 
8524  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax)
8525  {
8526  byte* nativeLabel;
8527  int labelByteCount = 0;
8528  if (label != null)
8529  {
8530  labelByteCount = Encoding.UTF8.GetByteCount(label);
8531  if (labelByteCount > Util.StackAllocationSizeLimit)
8532  {
8533  nativeLabel = Util.Allocate(labelByteCount + 1);
8534  }
8535  else
8536  {
8537  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8538  nativeLabel = nativeLabelStackBytes;
8539  }
8540 
8541  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8542  nativeLabel[nativeLabelOffset] = 0;
8543  }
8544  else
8545  {
8546  nativeLabel = null;
8547  }
8548 
8549  void* nativePData = pData.ToPointer();
8550  void* nativePMin = pMin.ToPointer();
8551  void* nativePMax = pMax.ToPointer();
8552  byte* nativeFormat = null;
8553  ImGuiSliders flag = 0;
8554  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8555  if (labelByteCount > Util.StackAllocationSizeLimit)
8556  {
8557  Util.Free(nativeLabel);
8558  }
8559 
8560  return ret != 0;
8561  }
8562 
8575  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
8576  {
8577  byte* nativeLabel;
8578  int labelByteCount = 0;
8579  if (label != null)
8580  {
8581  labelByteCount = Encoding.UTF8.GetByteCount(label);
8582  if (labelByteCount > Util.StackAllocationSizeLimit)
8583  {
8584  nativeLabel = Util.Allocate(labelByteCount + 1);
8585  }
8586  else
8587  {
8588  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8589  nativeLabel = nativeLabelStackBytes;
8590  }
8591 
8592  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8593  nativeLabel[nativeLabelOffset] = 0;
8594  }
8595  else
8596  {
8597  nativeLabel = null;
8598  }
8599 
8600  void* nativePData = pData.ToPointer();
8601  void* nativePMin = pMin.ToPointer();
8602  void* nativePMax = pMax.ToPointer();
8603  byte* nativeFormat;
8604  int formatByteCount = 0;
8605  if (format != null)
8606  {
8607  formatByteCount = Encoding.UTF8.GetByteCount(format);
8608  if (formatByteCount > Util.StackAllocationSizeLimit)
8609  {
8610  nativeFormat = Util.Allocate(formatByteCount + 1);
8611  }
8612  else
8613  {
8614  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8615  nativeFormat = nativeFormatStackBytes;
8616  }
8617 
8618  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8619  nativeFormat[nativeFormatOffset] = 0;
8620  }
8621  else
8622  {
8623  nativeFormat = null;
8624  }
8625 
8626  ImGuiSliders flag = 0;
8627  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8628  if (labelByteCount > Util.StackAllocationSizeLimit)
8629  {
8630  Util.Free(nativeLabel);
8631  }
8632 
8633  if (formatByteCount > Util.StackAllocationSizeLimit)
8634  {
8635  Util.Free(nativeFormat);
8636  }
8637 
8638  return ret != 0;
8639  }
8640 
8654  public static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
8655  {
8656  byte* nativeLabel;
8657  int labelByteCount = 0;
8658  if (label != null)
8659  {
8660  labelByteCount = Encoding.UTF8.GetByteCount(label);
8661  if (labelByteCount > Util.StackAllocationSizeLimit)
8662  {
8663  nativeLabel = Util.Allocate(labelByteCount + 1);
8664  }
8665  else
8666  {
8667  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
8668  nativeLabel = nativeLabelStackBytes;
8669  }
8670 
8671  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
8672  nativeLabel[nativeLabelOffset] = 0;
8673  }
8674  else
8675  {
8676  nativeLabel = null;
8677  }
8678 
8679  void* nativePData = pData.ToPointer();
8680  void* nativePMin = pMin.ToPointer();
8681  void* nativePMax = pMax.ToPointer();
8682  byte* nativeFormat;
8683  int formatByteCount = 0;
8684  if (format != null)
8685  {
8686  formatByteCount = Encoding.UTF8.GetByteCount(format);
8687  if (formatByteCount > Util.StackAllocationSizeLimit)
8688  {
8689  nativeFormat = Util.Allocate(formatByteCount + 1);
8690  }
8691  else
8692  {
8693  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
8694  nativeFormat = nativeFormatStackBytes;
8695  }
8696 
8697  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
8698  nativeFormat[nativeFormatOffset] = 0;
8699  }
8700  else
8701  {
8702  nativeFormat = null;
8703  }
8704 
8705  byte ret = ImGuiNative.igDragScalarN(nativeLabel, dataType, nativePData, components, vSpeed, nativePMin, nativePMax, nativeFormat, flag);
8706  if (labelByteCount > Util.StackAllocationSizeLimit)
8707  {
8708  Util.Free(nativeLabel);
8709  }
8710 
8711  if (formatByteCount > Util.StackAllocationSizeLimit)
8712  {
8713  Util.Free(nativeFormat);
8714  }
8715 
8716  return ret != 0;
8717  }
8718 
8723  public static void Dummy(Vector2F size)
8724  {
8725  ImGuiNative.igDummy(size);
8726  }
8727 
8731  public static void End()
8732  {
8733  ImGuiNative.igEnd();
8734  }
8735 
8739  public static void EndChild()
8740  {
8742  }
8743 
8747  public static void EndChildFrame()
8748  {
8750  }
8751 
8755  public static void EndCombo()
8756  {
8758  }
8759 
8763  public static void EndDisabled()
8764  {
8766  }
8767 
8771  public static void EndDragDropSource()
8772  {
8774  }
8775 
8779  public static void EndDragDropTarget()
8780  {
8782  }
8783 
8787  public static void EndFrame()
8788  {
8790  }
8791 
8795  public static void EndGroup()
8796  {
8798  }
8799 
8803  public static void EndListBox()
8804  {
8806  }
8807 
8811  public static void EndMainMenuBar()
8812  {
8814  }
8815 
8819  public static void EndMenu()
8820  {
8822  }
8823 
8827  public static void EndMenuBar()
8828  {
8830  }
8831 
8835  public static void EndPopup()
8836  {
8838  }
8839 
8843  public static void EndTabBar()
8844  {
8846  }
8847 
8851  public static void EndTabItem()
8852  {
8854  }
8855 
8859  public static void EndTable()
8860  {
8862  }
8863 
8867  public static void EndTooltip()
8868  {
8870  }
8871 
8877  public static ImGuiViewportPtr FindViewportById(uint id)
8878  {
8880  return new ImGuiViewportPtr(ret);
8881  }
8882 
8888  public static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platformHandle)
8889  {
8890  void* nativePlatformHandle = platformHandle.ToPointer();
8891  ImGuiViewport* ret = ImGuiNative.igFindViewportByPlatformHandle(nativePlatformHandle);
8892  return new ImGuiViewportPtr(ret);
8893  }
8894 
8901  public static void GetAllocatorFunctions(ref IntPtr pAllocFunc, ref IntPtr pFreeFunc, ref void* pUserData)
8902  {
8903  fixed (IntPtr* nativePAllocFunc = &pAllocFunc)
8904  {
8905  fixed (IntPtr* nativePFreeFunc = &pFreeFunc)
8906  {
8907  fixed (void** nativePUserData = &pUserData)
8908  {
8909  ImGuiNative.igGetAllocatorFunctions(nativePAllocFunc, nativePFreeFunc, nativePUserData);
8910  }
8911  }
8912  }
8913  }
8914 
8920  {
8922  return new ImDrawListPtr(ret);
8923  }
8924 
8931  {
8932  ImGuiViewport* nativeViewport = viewport.NativePtr;
8934  return new ImDrawListPtr(ret);
8935  }
8936 
8941  public static string GetClipboardText()
8942  {
8943  byte* ret = ImGuiNative.igGetClipboardText();
8944  return Util.StringFromPtr(ret);
8945  }
8946 
8952  public static uint GetColorU32(ImGuiCol idx)
8953  {
8954  float alphaMul = 1.0f;
8955  uint ret = ImGuiNative.igGetColorU32_Col(idx, alphaMul);
8956  return ret;
8957  }
8958 
8965  public static uint GetColorU32(ImGuiCol idx, float alphaMul)
8966  {
8967  uint ret = ImGuiNative.igGetColorU32_Col(idx, alphaMul);
8968  return ret;
8969  }
8970 
8976  public static uint GetColorU32(Vector4F col)
8977  {
8978  uint ret = ImGuiNative.igGetColorU32_Vec4(col);
8979  return ret;
8980  }
8981 
8987  public static uint GetColorU32(uint col)
8988  {
8989  uint ret = ImGuiNative.igGetColorU32_U32(col);
8990  return ret;
8991  }
8992 
8997  public static int GetColumnIndex()
8998  {
8999  int ret = ImGuiNative.igGetColumnIndex();
9000  return ret;
9001  }
9002 
9007  public static float GetColumnOffset()
9008  {
9009  int columnIndex = -1;
9010  float ret = ImGuiNative.igGetColumnOffset(columnIndex);
9011  return ret;
9012  }
9013 
9019  public static float GetColumnOffset(int columnIndex)
9020  {
9021  float ret = ImGuiNative.igGetColumnOffset(columnIndex);
9022  return ret;
9023  }
9024 
9029  public static int GetColumnsCount()
9030  {
9031  int ret = ImGuiNative.igGetColumnsCount();
9032  return ret;
9033  }
9034 
9039  public static float GetColumnWidth()
9040  {
9041  int columnIndex = -1;
9042  float ret = ImGuiNative.igGetColumnWidth(columnIndex);
9043  return ret;
9044  }
9045 
9051  public static float GetColumnWidth(int columnIndex)
9052  {
9053  float ret = ImGuiNative.igGetColumnWidth(columnIndex);
9054  return ret;
9055  }
9056 
9062  {
9063  Vector2F retval;
9065  return retval;
9066  }
9067 
9073  {
9074  Vector2F retval;
9076  return retval;
9077  }
9078 
9083  public static IntPtr GetCurrentContext()
9084  {
9085  IntPtr ret = ImGuiNative.igGetCurrentContext();
9086  return ret;
9087  }
9088 
9093  public static Vector2F GetCursorPos()
9094  {
9095  Vector2F retval;
9096  ImGuiNative.igGetCursorPos(&retval);
9097  return retval;
9098  }
9099 
9104  public static float GetCursorPosX()
9105  {
9106  float ret = ImGuiNative.igGetCursorPosX();
9107  return ret;
9108  }
9109 
9114  public static float GetCursorPosY()
9115  {
9116  float ret = ImGuiNative.igGetCursorPosY();
9117  return ret;
9118  }
9119 
9125  {
9126  Vector2F retval;
9128  return retval;
9129  }
9130 
9135  public static Vector2F GetCursorStartPos()
9136  {
9137  Vector2F retval;
9139  return retval;
9140  }
9141 
9147  {
9149  return new ImGuiPayloadPtr(ret);
9150  }
9151 
9156  public static ImDrawDataPtr GetDrawData()
9157  {
9159  return new ImDrawDataPtr(ret);
9160  }
9161 
9166  public static IntPtr GetDrawListSharedData()
9167  {
9168  IntPtr ret = ImGuiNative.igGetDrawListSharedData();
9169  return ret;
9170  }
9171 
9176  public static ImFontPtr GetFont()
9177  {
9178  ImFont* ret = ImGuiNative.igGetFont();
9179  return new ImFontPtr(ret);
9180  }
9181 
9186  public static float GetFontSize()
9187  {
9188  float ret = ImGuiNative.igGetFontSize();
9189  return ret;
9190  }
9191 
9197  {
9198  Vector2F retval;
9200  return retval;
9201  }
9202 
9208  {
9210  return new ImDrawListPtr(ret);
9211  }
9212 
9219  {
9220  ImGuiViewport* nativeViewport = viewport.NativePtr;
9222  return new ImDrawListPtr(ret);
9223  }
9224 
9229  public static int GetFrameCount()
9230  {
9231  int ret = ImGuiNative.igGetFrameCount();
9232  return ret;
9233  }
9234 
9239  public static float GetFrameHeight()
9240  {
9241  float ret = ImGuiNative.igGetFrameHeight();
9242  return ret;
9243  }
9244 
9249  public static float GetFrameHeightWithSpacing()
9250  {
9252  return ret;
9253  }
9254 
9260  public static uint GetId(string strId)
9261  {
9262  byte* nativeStrId;
9263  int strIdByteCount = 0;
9264  if (strId != null)
9265  {
9266  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9267  if (strIdByteCount > Util.StackAllocationSizeLimit)
9268  {
9269  nativeStrId = Util.Allocate(strIdByteCount + 1);
9270  }
9271  else
9272  {
9273  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9274  nativeStrId = nativeStrIdStackBytes;
9275  }
9276 
9277  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9278  nativeStrId[nativeStrIdOffset] = 0;
9279  }
9280  else
9281  {
9282  nativeStrId = null;
9283  }
9284 
9285  uint ret = ImGuiNative.igGetID_Str(nativeStrId);
9286  if (strIdByteCount > Util.StackAllocationSizeLimit)
9287  {
9288  Util.Free(nativeStrId);
9289  }
9290 
9291  return ret;
9292  }
9293 
9299  public static uint GetId(IntPtr ptrId)
9300  {
9301  void* nativePtrId = ptrId.ToPointer();
9302  uint ret = ImGuiNative.igGetID_Ptr(nativePtrId);
9303  return ret;
9304  }
9305 
9310  public static ImGuiIoPtr GetIo()
9311  {
9312  ImGuiIo* ret = ImGuiNative.igGetIO();
9313  return new ImGuiIoPtr(ret);
9314  }
9315 
9320  public static uint GetItemId()
9321  {
9322  uint ret = ImGuiNative.igGetItemID();
9323  return ret;
9324  }
9325 
9330  public static Vector2F GetItemRectMax()
9331  {
9332  Vector2F retval;
9333  ImGuiNative.igGetItemRectMax(&retval);
9334  return retval;
9335  }
9336 
9341  public static Vector2F GetItemRectMin()
9342  {
9343  Vector2F retval;
9344  ImGuiNative.igGetItemRectMin(&retval);
9345  return retval;
9346  }
9347 
9352  public static Vector2F GetItemRectSize()
9353  {
9354  Vector2F retval;
9355  ImGuiNative.igGetItemRectSize(&retval);
9356  return retval;
9357  }
9358 
9364  public static ImGuiKey GetKeyIndex(ImGuiKey key)
9365  {
9366  ImGuiKey ret = ImGuiNative.igGetKeyIndex(key);
9367  return ret;
9368  }
9369 
9375  public static string GetKeyName(ImGuiKey key)
9376  {
9377  byte* ret = ImGuiNative.igGetKeyName(key);
9378  return Util.StringFromPtr(ret);
9379  }
9380 
9388  public static int GetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
9389  {
9390  int ret = ImGuiNative.igGetKeyPressedAmount(key, repeatDelay, rate);
9391  return ret;
9392  }
9393 
9399  {
9401  return new ImGuiViewportPtr(ret);
9402  }
9403 
9409  public static int GetMouseClickedCount(ImGuiMouseButton button)
9410  {
9411  int ret = ImGuiNative.igGetMouseClickedCount(button);
9412  return ret;
9413  }
9414 
9420  {
9422  return ret;
9423  }
9424 
9429  public static Vector2F GetMouseDragDelta()
9430  {
9431  Vector2F retval;
9432  ImGuiMouseButton button = 0;
9433  float lockThreshold = -1.0f;
9434  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9435  return retval;
9436  }
9437 
9444  {
9445  Vector2F retval;
9446  float lockThreshold = -1.0f;
9447  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9448  return retval;
9449  }
9450 
9457  public static Vector2F GetMouseDragDelta(ImGuiMouseButton button, float lockThreshold)
9458  {
9459  Vector2F retval;
9460  ImGuiNative.igGetMouseDragDelta(&retval, button, lockThreshold);
9461  return retval;
9462  }
9463 
9468  public static Vector2F GetMousePos()
9469  {
9470  Vector2F retval;
9471  ImGuiNative.igGetMousePos(&retval);
9472  return retval;
9473  }
9474 
9480  {
9481  Vector2F retval;
9483  return retval;
9484  }
9485 
9491  {
9493  return new ImGuiPlatformIoPtr(ret);
9494  }
9495 
9500  public static float GetScrollMaxX()
9501  {
9502  float ret = ImGuiNative.igGetScrollMaxX();
9503  return ret;
9504  }
9505 
9510  public static float GetScrollMaxY()
9511  {
9512  float ret = ImGuiNative.igGetScrollMaxY();
9513  return ret;
9514  }
9515 
9520  public static float GetScrollX()
9521  {
9522  float ret = ImGuiNative.igGetScrollX();
9523  return ret;
9524  }
9525 
9530  public static float GetScrollY()
9531  {
9532  float ret = ImGuiNative.igGetScrollY();
9533  return ret;
9534  }
9535 
9541  {
9543  return new ImGuiStoragePtr(ret);
9544  }
9545 
9550  public static ImGuiStylePtr GetStyle()
9551  {
9553  return new ImGuiStylePtr(ret);
9554  }
9555 
9561  public static string GetStyleColorName(ImGuiCol idx)
9562  {
9563  byte* ret = ImGuiNative.igGetStyleColorName(idx);
9564  return Util.StringFromPtr(ret);
9565  }
9566 
9573  {
9575  return ret;
9576  }
9577 
9582  public static float GetTextLineHeight()
9583  {
9584  float ret = ImGuiNative.igGetTextLineHeight();
9585  return ret;
9586  }
9587 
9592  public static float GetTextLineHeightWithSpacing()
9593  {
9595  return ret;
9596  }
9597 
9602  public static double GetTime()
9603  {
9604  double ret = ImGuiNative.igGetTime();
9605  return ret;
9606  }
9607 
9612  public static float GetTreeNodeToLabelSpacing()
9613  {
9615  return ret;
9616  }
9617 
9622  public static string GetVersion()
9623  {
9624  byte* ret = ImGuiNative.igGetVersion();
9625  return Util.StringFromPtr(ret);
9626  }
9627 
9633  {
9634  Vector2F retval;
9636  return retval;
9637  }
9638 
9644  {
9645  Vector2F retval;
9647  return retval;
9648  }
9649 
9654  public static uint GetWindowDockId()
9655  {
9656  uint ret = ImGuiNative.igGetWindowDockID();
9657  return ret;
9658  }
9659 
9664  public static float GetWindowDpiScale()
9665  {
9666  float ret = ImGuiNative.igGetWindowDpiScale();
9667  return ret;
9668  }
9669 
9675  {
9677  return new ImDrawListPtr(ret);
9678  }
9679 
9684  public static float GetWindowHeight()
9685  {
9686  float ret = ImGuiNative.igGetWindowHeight();
9687  return ret;
9688  }
9689 
9694  public static Vector2F GetWindowPos()
9695  {
9696  Vector2F retval;
9697  ImGuiNative.igGetWindowPos(&retval);
9698  return retval;
9699  }
9700 
9705  public static Vector2F GetWindowSize()
9706  {
9707  Vector2F retval;
9708  ImGuiNative.igGetWindowSize(&retval);
9709  return retval;
9710  }
9711 
9717  {
9719  return new ImGuiViewportPtr(ret);
9720  }
9721 
9726  public static float GetWindowWidth()
9727  {
9728  float ret = ImGuiNative.igGetWindowWidth();
9729  return ret;
9730  }
9731 
9737  public static void Image(IntPtr userTextureId, Vector2F size)
9738  {
9739  Vector2F uv0 = new Vector2F();
9740  Vector2F uv1 = new Vector2F(1, 1);
9741  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9742  Vector4F borderCol = new Vector4F();
9743  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9744  }
9745 
9752  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0)
9753  {
9754  Vector2F uv1 = new Vector2F(1, 1);
9755  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9756  Vector4F borderCol = new Vector4F();
9757  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9758  }
9759 
9767  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
9768  {
9769  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9770  Vector4F borderCol = new Vector4F();
9771  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9772  }
9773 
9782  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol)
9783  {
9784  Vector4F borderCol = new Vector4F();
9785  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9786  }
9787 
9797  public static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
9798  {
9799  ImGuiNative.igImage(userTextureId, size, uv0, uv1, tintCol, borderCol);
9800  }
9801 
9809  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size)
9810  {
9811  byte* nativeStrId;
9812  int strIdByteCount = 0;
9813  if (strId != null)
9814  {
9815  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9816  if (strIdByteCount > Util.StackAllocationSizeLimit)
9817  {
9818  nativeStrId = Util.Allocate(strIdByteCount + 1);
9819  }
9820  else
9821  {
9822  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9823  nativeStrId = nativeStrIdStackBytes;
9824  }
9825 
9826  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9827  nativeStrId[nativeStrIdOffset] = 0;
9828  }
9829  else
9830  {
9831  nativeStrId = null;
9832  }
9833 
9834  Vector2F uv0 = new Vector2F();
9835  Vector2F uv1 = new Vector2F(1, 1);
9836  Vector4F bgCol = new Vector4F();
9837  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9838  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9839  if (strIdByteCount > Util.StackAllocationSizeLimit)
9840  {
9841  Util.Free(nativeStrId);
9842  }
9843 
9844  return ret != 0;
9845  }
9846 
9855  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0)
9856  {
9857  byte* nativeStrId;
9858  int strIdByteCount = 0;
9859  if (strId != null)
9860  {
9861  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9862  if (strIdByteCount > Util.StackAllocationSizeLimit)
9863  {
9864  nativeStrId = Util.Allocate(strIdByteCount + 1);
9865  }
9866  else
9867  {
9868  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9869  nativeStrId = nativeStrIdStackBytes;
9870  }
9871 
9872  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9873  nativeStrId[nativeStrIdOffset] = 0;
9874  }
9875  else
9876  {
9877  nativeStrId = null;
9878  }
9879 
9880  Vector2F uv1 = new Vector2F(1, 1);
9881  Vector4F bgCol = new Vector4F();
9882  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9883  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9884  if (strIdByteCount > Util.StackAllocationSizeLimit)
9885  {
9886  Util.Free(nativeStrId);
9887  }
9888 
9889  return ret != 0;
9890  }
9891 
9901  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
9902  {
9903  byte* nativeStrId;
9904  int strIdByteCount = 0;
9905  if (strId != null)
9906  {
9907  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9908  if (strIdByteCount > Util.StackAllocationSizeLimit)
9909  {
9910  nativeStrId = Util.Allocate(strIdByteCount + 1);
9911  }
9912  else
9913  {
9914  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9915  nativeStrId = nativeStrIdStackBytes;
9916  }
9917 
9918  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9919  nativeStrId[nativeStrIdOffset] = 0;
9920  }
9921  else
9922  {
9923  nativeStrId = null;
9924  }
9925 
9926  Vector4F bgCol = new Vector4F();
9927  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9928  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9929  if (strIdByteCount > Util.StackAllocationSizeLimit)
9930  {
9931  Util.Free(nativeStrId);
9932  }
9933 
9934  return ret != 0;
9935  }
9936 
9947  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol)
9948  {
9949  byte* nativeStrId;
9950  int strIdByteCount = 0;
9951  if (strId != null)
9952  {
9953  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
9954  if (strIdByteCount > Util.StackAllocationSizeLimit)
9955  {
9956  nativeStrId = Util.Allocate(strIdByteCount + 1);
9957  }
9958  else
9959  {
9960  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
9961  nativeStrId = nativeStrIdStackBytes;
9962  }
9963 
9964  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
9965  nativeStrId[nativeStrIdOffset] = 0;
9966  }
9967  else
9968  {
9969  nativeStrId = null;
9970  }
9971 
9972  Vector4F tintCol = new Vector4F(1, 1, 1, 1);
9973  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
9974  if (strIdByteCount > Util.StackAllocationSizeLimit)
9975  {
9976  Util.Free(nativeStrId);
9977  }
9978 
9979  return ret != 0;
9980  }
9981 
9993  public static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
9994  {
9995  byte* nativeStrId;
9996  int strIdByteCount = 0;
9997  if (strId != null)
9998  {
9999  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
10000  if (strIdByteCount > Util.StackAllocationSizeLimit)
10001  {
10002  nativeStrId = Util.Allocate(strIdByteCount + 1);
10003  }
10004  else
10005  {
10006  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
10007  nativeStrId = nativeStrIdStackBytes;
10008  }
10009 
10010  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
10011  nativeStrId[nativeStrIdOffset] = 0;
10012  }
10013  else
10014  {
10015  nativeStrId = null;
10016  }
10017 
10018  byte ret = ImGuiNative.igImageButton(nativeStrId, userTextureId, size, uv0, uv1, bgCol, tintCol);
10019  if (strIdByteCount > Util.StackAllocationSizeLimit)
10020  {
10021  Util.Free(nativeStrId);
10022  }
10023 
10024  return ret != 0;
10025  }
10026 
10030  public static void Indent()
10031  {
10032  float indentW = 0.0f;
10033  ImGuiNative.igIndent(indentW);
10034  }
10035 
10040  public static void Indent(float indentW)
10041  {
10042  ImGuiNative.igIndent(indentW);
10043  }
10044 
10051  public static bool InputDouble(string label, ref double v)
10052  {
10053  byte* nativeLabel;
10054  int labelByteCount = 0;
10055  if (label != null)
10056  {
10057  labelByteCount = Encoding.UTF8.GetByteCount(label);
10058  if (labelByteCount > Util.StackAllocationSizeLimit)
10059  {
10060  nativeLabel = Util.Allocate(labelByteCount + 1);
10061  }
10062  else
10063  {
10064  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10065  nativeLabel = nativeLabelStackBytes;
10066  }
10067 
10068  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10069  nativeLabel[nativeLabelOffset] = 0;
10070  }
10071  else
10072  {
10073  nativeLabel = null;
10074  }
10075 
10076  double step = 0.0;
10077  double stepFast = 0.0;
10078  byte* nativeFormat;
10079  int formatByteCount = 0;
10080  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10081  if (formatByteCount > Util.StackAllocationSizeLimit)
10082  {
10083  nativeFormat = Util.Allocate(formatByteCount + 1);
10084  }
10085  else
10086  {
10087  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10088  nativeFormat = nativeFormatStackBytes;
10089  }
10090 
10091  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10092  nativeFormat[nativeFormatOffset] = 0;
10093  ImGuiInputTexts flag = 0;
10094  fixed (double* nativeV = &v)
10095  {
10096  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10097  if (labelByteCount > Util.StackAllocationSizeLimit)
10098  {
10099  Util.Free(nativeLabel);
10100  }
10101 
10102  if (formatByteCount > Util.StackAllocationSizeLimit)
10103  {
10104  Util.Free(nativeFormat);
10105  }
10106 
10107  return ret != 0;
10108  }
10109  }
10110 
10118  public static bool InputDouble(string label, ref double v, double step)
10119  {
10120  byte* nativeLabel;
10121  int labelByteCount = 0;
10122  if (label != null)
10123  {
10124  labelByteCount = Encoding.UTF8.GetByteCount(label);
10125  if (labelByteCount > Util.StackAllocationSizeLimit)
10126  {
10127  nativeLabel = Util.Allocate(labelByteCount + 1);
10128  }
10129  else
10130  {
10131  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10132  nativeLabel = nativeLabelStackBytes;
10133  }
10134 
10135  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10136  nativeLabel[nativeLabelOffset] = 0;
10137  }
10138  else
10139  {
10140  nativeLabel = null;
10141  }
10142 
10143  double stepFast = 0.0;
10144  byte* nativeFormat;
10145  int formatByteCount = 0;
10146  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10147  if (formatByteCount > Util.StackAllocationSizeLimit)
10148  {
10149  nativeFormat = Util.Allocate(formatByteCount + 1);
10150  }
10151  else
10152  {
10153  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10154  nativeFormat = nativeFormatStackBytes;
10155  }
10156 
10157  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10158  nativeFormat[nativeFormatOffset] = 0;
10159  ImGuiInputTexts flag = 0;
10160  fixed (double* nativeV = &v)
10161  {
10162  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10163  if (labelByteCount > Util.StackAllocationSizeLimit)
10164  {
10165  Util.Free(nativeLabel);
10166  }
10167 
10168  if (formatByteCount > Util.StackAllocationSizeLimit)
10169  {
10170  Util.Free(nativeFormat);
10171  }
10172 
10173  return ret != 0;
10174  }
10175  }
10176 
10185  public static bool InputDouble(string label, ref double v, double step, double stepFast)
10186  {
10187  byte* nativeLabel;
10188  int labelByteCount = 0;
10189  if (label != null)
10190  {
10191  labelByteCount = Encoding.UTF8.GetByteCount(label);
10192  if (labelByteCount > Util.StackAllocationSizeLimit)
10193  {
10194  nativeLabel = Util.Allocate(labelByteCount + 1);
10195  }
10196  else
10197  {
10198  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10199  nativeLabel = nativeLabelStackBytes;
10200  }
10201 
10202  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10203  nativeLabel[nativeLabelOffset] = 0;
10204  }
10205  else
10206  {
10207  nativeLabel = null;
10208  }
10209 
10210  byte* nativeFormat;
10211  int formatByteCount = 0;
10212  formatByteCount = Encoding.UTF8.GetByteCount("%.6f");
10213  if (formatByteCount > Util.StackAllocationSizeLimit)
10214  {
10215  nativeFormat = Util.Allocate(formatByteCount + 1);
10216  }
10217  else
10218  {
10219  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10220  nativeFormat = nativeFormatStackBytes;
10221  }
10222 
10223  int nativeFormatOffset = Util.GetUtf8("%.6f", nativeFormat, formatByteCount);
10224  nativeFormat[nativeFormatOffset] = 0;
10225  ImGuiInputTexts flag = 0;
10226  fixed (double* nativeV = &v)
10227  {
10228  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10229  if (labelByteCount > Util.StackAllocationSizeLimit)
10230  {
10231  Util.Free(nativeLabel);
10232  }
10233 
10234  if (formatByteCount > Util.StackAllocationSizeLimit)
10235  {
10236  Util.Free(nativeFormat);
10237  }
10238 
10239  return ret != 0;
10240  }
10241  }
10242 
10252  public static bool InputDouble(string label, ref double v, double step, double stepFast, string format)
10253  {
10254  byte* nativeLabel;
10255  int labelByteCount = 0;
10256  if (label != null)
10257  {
10258  labelByteCount = Encoding.UTF8.GetByteCount(label);
10259  if (labelByteCount > Util.StackAllocationSizeLimit)
10260  {
10261  nativeLabel = Util.Allocate(labelByteCount + 1);
10262  }
10263  else
10264  {
10265  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10266  nativeLabel = nativeLabelStackBytes;
10267  }
10268 
10269  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10270  nativeLabel[nativeLabelOffset] = 0;
10271  }
10272  else
10273  {
10274  nativeLabel = null;
10275  }
10276 
10277  byte* nativeFormat;
10278  int formatByteCount = 0;
10279  if (format != null)
10280  {
10281  formatByteCount = Encoding.UTF8.GetByteCount(format);
10282  if (formatByteCount > Util.StackAllocationSizeLimit)
10283  {
10284  nativeFormat = Util.Allocate(formatByteCount + 1);
10285  }
10286  else
10287  {
10288  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10289  nativeFormat = nativeFormatStackBytes;
10290  }
10291 
10292  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10293  nativeFormat[nativeFormatOffset] = 0;
10294  }
10295  else
10296  {
10297  nativeFormat = null;
10298  }
10299 
10300  ImGuiInputTexts flag = 0;
10301  fixed (double* nativeV = &v)
10302  {
10303  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10304  if (labelByteCount > Util.StackAllocationSizeLimit)
10305  {
10306  Util.Free(nativeLabel);
10307  }
10308 
10309  if (formatByteCount > Util.StackAllocationSizeLimit)
10310  {
10311  Util.Free(nativeFormat);
10312  }
10313 
10314  return ret != 0;
10315  }
10316  }
10317 
10328  public static bool InputDouble(string label, ref double v, double step, double stepFast, string format, ImGuiInputTexts flag)
10329  {
10330  byte* nativeLabel;
10331  int labelByteCount = 0;
10332  if (label != null)
10333  {
10334  labelByteCount = Encoding.UTF8.GetByteCount(label);
10335  if (labelByteCount > Util.StackAllocationSizeLimit)
10336  {
10337  nativeLabel = Util.Allocate(labelByteCount + 1);
10338  }
10339  else
10340  {
10341  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10342  nativeLabel = nativeLabelStackBytes;
10343  }
10344 
10345  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10346  nativeLabel[nativeLabelOffset] = 0;
10347  }
10348  else
10349  {
10350  nativeLabel = null;
10351  }
10352 
10353  byte* nativeFormat;
10354  int formatByteCount = 0;
10355  if (format != null)
10356  {
10357  formatByteCount = Encoding.UTF8.GetByteCount(format);
10358  if (formatByteCount > Util.StackAllocationSizeLimit)
10359  {
10360  nativeFormat = Util.Allocate(formatByteCount + 1);
10361  }
10362  else
10363  {
10364  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10365  nativeFormat = nativeFormatStackBytes;
10366  }
10367 
10368  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10369  nativeFormat[nativeFormatOffset] = 0;
10370  }
10371  else
10372  {
10373  nativeFormat = null;
10374  }
10375 
10376  fixed (double* nativeV = &v)
10377  {
10378  byte ret = ImGuiNative.igInputDouble(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10379  if (labelByteCount > Util.StackAllocationSizeLimit)
10380  {
10381  Util.Free(nativeLabel);
10382  }
10383 
10384  if (formatByteCount > Util.StackAllocationSizeLimit)
10385  {
10386  Util.Free(nativeFormat);
10387  }
10388 
10389  return ret != 0;
10390  }
10391  }
10392 
10399  public static bool InputFloat(string label, ref float v)
10400  {
10401  byte* nativeLabel;
10402  int labelByteCount = 0;
10403  if (label != null)
10404  {
10405  labelByteCount = Encoding.UTF8.GetByteCount(label);
10406  if (labelByteCount > Util.StackAllocationSizeLimit)
10407  {
10408  nativeLabel = Util.Allocate(labelByteCount + 1);
10409  }
10410  else
10411  {
10412  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10413  nativeLabel = nativeLabelStackBytes;
10414  }
10415 
10416  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10417  nativeLabel[nativeLabelOffset] = 0;
10418  }
10419  else
10420  {
10421  nativeLabel = null;
10422  }
10423 
10424  float step = 0.0f;
10425  float stepFast = 0.0f;
10426  byte* nativeFormat;
10427  int formatByteCount = 0;
10428  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10429  if (formatByteCount > Util.StackAllocationSizeLimit)
10430  {
10431  nativeFormat = Util.Allocate(formatByteCount + 1);
10432  }
10433  else
10434  {
10435  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10436  nativeFormat = nativeFormatStackBytes;
10437  }
10438 
10439  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10440  nativeFormat[nativeFormatOffset] = 0;
10441  ImGuiInputTexts flag = 0;
10442  fixed (float* nativeV = &v)
10443  {
10444  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10445  if (labelByteCount > Util.StackAllocationSizeLimit)
10446  {
10447  Util.Free(nativeLabel);
10448  }
10449 
10450  if (formatByteCount > Util.StackAllocationSizeLimit)
10451  {
10452  Util.Free(nativeFormat);
10453  }
10454 
10455  return ret != 0;
10456  }
10457  }
10458 
10466  public static bool InputFloat(string label, ref float v, float step)
10467  {
10468  byte* nativeLabel;
10469  int labelByteCount = 0;
10470  if (label != null)
10471  {
10472  labelByteCount = Encoding.UTF8.GetByteCount(label);
10473  if (labelByteCount > Util.StackAllocationSizeLimit)
10474  {
10475  nativeLabel = Util.Allocate(labelByteCount + 1);
10476  }
10477  else
10478  {
10479  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10480  nativeLabel = nativeLabelStackBytes;
10481  }
10482 
10483  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10484  nativeLabel[nativeLabelOffset] = 0;
10485  }
10486  else
10487  {
10488  nativeLabel = null;
10489  }
10490 
10491  float stepFast = 0.0f;
10492  byte* nativeFormat;
10493  int formatByteCount = 0;
10494  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10495  if (formatByteCount > Util.StackAllocationSizeLimit)
10496  {
10497  nativeFormat = Util.Allocate(formatByteCount + 1);
10498  }
10499  else
10500  {
10501  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10502  nativeFormat = nativeFormatStackBytes;
10503  }
10504 
10505  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10506  nativeFormat[nativeFormatOffset] = 0;
10507  ImGuiInputTexts flag = 0;
10508  fixed (float* nativeV = &v)
10509  {
10510  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10511  if (labelByteCount > Util.StackAllocationSizeLimit)
10512  {
10513  Util.Free(nativeLabel);
10514  }
10515 
10516  if (formatByteCount > Util.StackAllocationSizeLimit)
10517  {
10518  Util.Free(nativeFormat);
10519  }
10520 
10521  return ret != 0;
10522  }
10523  }
10524 
10533  public static bool InputFloat(string label, ref float v, float step, float stepFast)
10534  {
10535  byte* nativeLabel;
10536  int labelByteCount = 0;
10537  if (label != null)
10538  {
10539  labelByteCount = Encoding.UTF8.GetByteCount(label);
10540  if (labelByteCount > Util.StackAllocationSizeLimit)
10541  {
10542  nativeLabel = Util.Allocate(labelByteCount + 1);
10543  }
10544  else
10545  {
10546  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10547  nativeLabel = nativeLabelStackBytes;
10548  }
10549 
10550  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10551  nativeLabel[nativeLabelOffset] = 0;
10552  }
10553  else
10554  {
10555  nativeLabel = null;
10556  }
10557 
10558  byte* nativeFormat;
10559  int formatByteCount = 0;
10560  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10561  if (formatByteCount > Util.StackAllocationSizeLimit)
10562  {
10563  nativeFormat = Util.Allocate(formatByteCount + 1);
10564  }
10565  else
10566  {
10567  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10568  nativeFormat = nativeFormatStackBytes;
10569  }
10570 
10571  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10572  nativeFormat[nativeFormatOffset] = 0;
10573  ImGuiInputTexts flag = 0;
10574  fixed (float* nativeV = &v)
10575  {
10576  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10577  if (labelByteCount > Util.StackAllocationSizeLimit)
10578  {
10579  Util.Free(nativeLabel);
10580  }
10581 
10582  if (formatByteCount > Util.StackAllocationSizeLimit)
10583  {
10584  Util.Free(nativeFormat);
10585  }
10586 
10587  return ret != 0;
10588  }
10589  }
10590 
10600  public static bool InputFloat(string label, ref float v, float step, float stepFast, string format)
10601  {
10602  byte* nativeLabel;
10603  int labelByteCount = 0;
10604  if (label != null)
10605  {
10606  labelByteCount = Encoding.UTF8.GetByteCount(label);
10607  if (labelByteCount > Util.StackAllocationSizeLimit)
10608  {
10609  nativeLabel = Util.Allocate(labelByteCount + 1);
10610  }
10611  else
10612  {
10613  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10614  nativeLabel = nativeLabelStackBytes;
10615  }
10616 
10617  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10618  nativeLabel[nativeLabelOffset] = 0;
10619  }
10620  else
10621  {
10622  nativeLabel = null;
10623  }
10624 
10625  byte* nativeFormat;
10626  int formatByteCount = 0;
10627  if (format != null)
10628  {
10629  formatByteCount = Encoding.UTF8.GetByteCount(format);
10630  if (formatByteCount > Util.StackAllocationSizeLimit)
10631  {
10632  nativeFormat = Util.Allocate(formatByteCount + 1);
10633  }
10634  else
10635  {
10636  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10637  nativeFormat = nativeFormatStackBytes;
10638  }
10639 
10640  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10641  nativeFormat[nativeFormatOffset] = 0;
10642  }
10643  else
10644  {
10645  nativeFormat = null;
10646  }
10647 
10648  ImGuiInputTexts flag = 0;
10649  fixed (float* nativeV = &v)
10650  {
10651  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10652  if (labelByteCount > Util.StackAllocationSizeLimit)
10653  {
10654  Util.Free(nativeLabel);
10655  }
10656 
10657  if (formatByteCount > Util.StackAllocationSizeLimit)
10658  {
10659  Util.Free(nativeFormat);
10660  }
10661 
10662  return ret != 0;
10663  }
10664  }
10665 
10676  public static bool InputFloat(string label, ref float v, float step, float stepFast, string format, ImGuiInputTexts flag)
10677  {
10678  byte* nativeLabel;
10679  int labelByteCount = 0;
10680  if (label != null)
10681  {
10682  labelByteCount = Encoding.UTF8.GetByteCount(label);
10683  if (labelByteCount > Util.StackAllocationSizeLimit)
10684  {
10685  nativeLabel = Util.Allocate(labelByteCount + 1);
10686  }
10687  else
10688  {
10689  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10690  nativeLabel = nativeLabelStackBytes;
10691  }
10692 
10693  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10694  nativeLabel[nativeLabelOffset] = 0;
10695  }
10696  else
10697  {
10698  nativeLabel = null;
10699  }
10700 
10701  byte* nativeFormat;
10702  int formatByteCount = 0;
10703  if (format != null)
10704  {
10705  formatByteCount = Encoding.UTF8.GetByteCount(format);
10706  if (formatByteCount > Util.StackAllocationSizeLimit)
10707  {
10708  nativeFormat = Util.Allocate(formatByteCount + 1);
10709  }
10710  else
10711  {
10712  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10713  nativeFormat = nativeFormatStackBytes;
10714  }
10715 
10716  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10717  nativeFormat[nativeFormatOffset] = 0;
10718  }
10719  else
10720  {
10721  nativeFormat = null;
10722  }
10723 
10724  fixed (float* nativeV = &v)
10725  {
10726  byte ret = ImGuiNative.igInputFloat(nativeLabel, nativeV, step, stepFast, nativeFormat, flag);
10727  if (labelByteCount > Util.StackAllocationSizeLimit)
10728  {
10729  Util.Free(nativeLabel);
10730  }
10731 
10732  if (formatByteCount > Util.StackAllocationSizeLimit)
10733  {
10734  Util.Free(nativeFormat);
10735  }
10736 
10737  return ret != 0;
10738  }
10739  }
10740 
10747  public static bool InputFloat2(string label, ref Vector2F v)
10748  {
10749  byte* nativeLabel;
10750  int labelByteCount = 0;
10751  if (label != null)
10752  {
10753  labelByteCount = Encoding.UTF8.GetByteCount(label);
10754  if (labelByteCount > Util.StackAllocationSizeLimit)
10755  {
10756  nativeLabel = Util.Allocate(labelByteCount + 1);
10757  }
10758  else
10759  {
10760  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10761  nativeLabel = nativeLabelStackBytes;
10762  }
10763 
10764  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10765  nativeLabel[nativeLabelOffset] = 0;
10766  }
10767  else
10768  {
10769  nativeLabel = null;
10770  }
10771 
10772  byte* nativeFormat;
10773  int formatByteCount = 0;
10774  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10775  if (formatByteCount > Util.StackAllocationSizeLimit)
10776  {
10777  nativeFormat = Util.Allocate(formatByteCount + 1);
10778  }
10779  else
10780  {
10781  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10782  nativeFormat = nativeFormatStackBytes;
10783  }
10784 
10785  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10786  nativeFormat[nativeFormatOffset] = 0;
10787  ImGuiInputTexts flag = 0;
10788  fixed (Vector2F* nativeV = &v)
10789  {
10790  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flag);
10791  if (labelByteCount > Util.StackAllocationSizeLimit)
10792  {
10793  Util.Free(nativeLabel);
10794  }
10795 
10796  if (formatByteCount > Util.StackAllocationSizeLimit)
10797  {
10798  Util.Free(nativeFormat);
10799  }
10800 
10801  return ret != 0;
10802  }
10803  }
10804 
10812  public static bool InputFloat2(string label, ref Vector2F v, string format)
10813  {
10814  byte* nativeLabel;
10815  int labelByteCount = 0;
10816  if (label != null)
10817  {
10818  labelByteCount = Encoding.UTF8.GetByteCount(label);
10819  if (labelByteCount > Util.StackAllocationSizeLimit)
10820  {
10821  nativeLabel = Util.Allocate(labelByteCount + 1);
10822  }
10823  else
10824  {
10825  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10826  nativeLabel = nativeLabelStackBytes;
10827  }
10828 
10829  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10830  nativeLabel[nativeLabelOffset] = 0;
10831  }
10832  else
10833  {
10834  nativeLabel = null;
10835  }
10836 
10837  byte* nativeFormat;
10838  int formatByteCount = 0;
10839  if (format != null)
10840  {
10841  formatByteCount = Encoding.UTF8.GetByteCount(format);
10842  if (formatByteCount > Util.StackAllocationSizeLimit)
10843  {
10844  nativeFormat = Util.Allocate(formatByteCount + 1);
10845  }
10846  else
10847  {
10848  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10849  nativeFormat = nativeFormatStackBytes;
10850  }
10851 
10852  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10853  nativeFormat[nativeFormatOffset] = 0;
10854  }
10855  else
10856  {
10857  nativeFormat = null;
10858  }
10859 
10860  ImGuiInputTexts flag = 0;
10861  fixed (Vector2F* nativeV = &v)
10862  {
10863  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flag);
10864  if (labelByteCount > Util.StackAllocationSizeLimit)
10865  {
10866  Util.Free(nativeLabel);
10867  }
10868 
10869  if (formatByteCount > Util.StackAllocationSizeLimit)
10870  {
10871  Util.Free(nativeFormat);
10872  }
10873 
10874  return ret != 0;
10875  }
10876  }
10877 
10886  public static bool InputFloat2(string label, ref Vector2F v, string format, ImGuiInputTexts flag)
10887  {
10888  byte* nativeLabel;
10889  int labelByteCount = 0;
10890  if (label != null)
10891  {
10892  labelByteCount = Encoding.UTF8.GetByteCount(label);
10893  if (labelByteCount > Util.StackAllocationSizeLimit)
10894  {
10895  nativeLabel = Util.Allocate(labelByteCount + 1);
10896  }
10897  else
10898  {
10899  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10900  nativeLabel = nativeLabelStackBytes;
10901  }
10902 
10903  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10904  nativeLabel[nativeLabelOffset] = 0;
10905  }
10906  else
10907  {
10908  nativeLabel = null;
10909  }
10910 
10911  byte* nativeFormat;
10912  int formatByteCount = 0;
10913  if (format != null)
10914  {
10915  formatByteCount = Encoding.UTF8.GetByteCount(format);
10916  if (formatByteCount > Util.StackAllocationSizeLimit)
10917  {
10918  nativeFormat = Util.Allocate(formatByteCount + 1);
10919  }
10920  else
10921  {
10922  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10923  nativeFormat = nativeFormatStackBytes;
10924  }
10925 
10926  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
10927  nativeFormat[nativeFormatOffset] = 0;
10928  }
10929  else
10930  {
10931  nativeFormat = null;
10932  }
10933 
10934  fixed (Vector2F* nativeV = &v)
10935  {
10936  byte ret = ImGuiNative.igInputFloat2(nativeLabel, nativeV, nativeFormat, flag);
10937  if (labelByteCount > Util.StackAllocationSizeLimit)
10938  {
10939  Util.Free(nativeLabel);
10940  }
10941 
10942  if (formatByteCount > Util.StackAllocationSizeLimit)
10943  {
10944  Util.Free(nativeFormat);
10945  }
10946 
10947  return ret != 0;
10948  }
10949  }
10950 
10957  public static bool InputFloat3(string label, ref Vector3F v)
10958  {
10959  byte* nativeLabel;
10960  int labelByteCount = 0;
10961  if (label != null)
10962  {
10963  labelByteCount = Encoding.UTF8.GetByteCount(label);
10964  if (labelByteCount > Util.StackAllocationSizeLimit)
10965  {
10966  nativeLabel = Util.Allocate(labelByteCount + 1);
10967  }
10968  else
10969  {
10970  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
10971  nativeLabel = nativeLabelStackBytes;
10972  }
10973 
10974  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
10975  nativeLabel[nativeLabelOffset] = 0;
10976  }
10977  else
10978  {
10979  nativeLabel = null;
10980  }
10981 
10982  byte* nativeFormat;
10983  int formatByteCount = 0;
10984  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
10985  if (formatByteCount > Util.StackAllocationSizeLimit)
10986  {
10987  nativeFormat = Util.Allocate(formatByteCount + 1);
10988  }
10989  else
10990  {
10991  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
10992  nativeFormat = nativeFormatStackBytes;
10993  }
10994 
10995  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
10996  nativeFormat[nativeFormatOffset] = 0;
10997  ImGuiInputTexts flag = 0;
10998  fixed (Vector3F* nativeV = &v)
10999  {
11000  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flag);
11001  if (labelByteCount > Util.StackAllocationSizeLimit)
11002  {
11003  Util.Free(nativeLabel);
11004  }
11005 
11006  if (formatByteCount > Util.StackAllocationSizeLimit)
11007  {
11008  Util.Free(nativeFormat);
11009  }
11010 
11011  return ret != 0;
11012  }
11013  }
11014 
11022  public static bool InputFloat3(string label, ref Vector3F v, string format)
11023  {
11024  byte* nativeLabel;
11025  int labelByteCount = 0;
11026  if (label != null)
11027  {
11028  labelByteCount = Encoding.UTF8.GetByteCount(label);
11029  if (labelByteCount > Util.StackAllocationSizeLimit)
11030  {
11031  nativeLabel = Util.Allocate(labelByteCount + 1);
11032  }
11033  else
11034  {
11035  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11036  nativeLabel = nativeLabelStackBytes;
11037  }
11038 
11039  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11040  nativeLabel[nativeLabelOffset] = 0;
11041  }
11042  else
11043  {
11044  nativeLabel = null;
11045  }
11046 
11047  byte* nativeFormat;
11048  int formatByteCount = 0;
11049  if (format != null)
11050  {
11051  formatByteCount = Encoding.UTF8.GetByteCount(format);
11052  if (formatByteCount > Util.StackAllocationSizeLimit)
11053  {
11054  nativeFormat = Util.Allocate(formatByteCount + 1);
11055  }
11056  else
11057  {
11058  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11059  nativeFormat = nativeFormatStackBytes;
11060  }
11061 
11062  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11063  nativeFormat[nativeFormatOffset] = 0;
11064  }
11065  else
11066  {
11067  nativeFormat = null;
11068  }
11069 
11070  ImGuiInputTexts flag = 0;
11071  fixed (Vector3F* nativeV = &v)
11072  {
11073  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flag);
11074  if (labelByteCount > Util.StackAllocationSizeLimit)
11075  {
11076  Util.Free(nativeLabel);
11077  }
11078 
11079  if (formatByteCount > Util.StackAllocationSizeLimit)
11080  {
11081  Util.Free(nativeFormat);
11082  }
11083 
11084  return ret != 0;
11085  }
11086  }
11087 
11096  public static bool InputFloat3(string label, ref Vector3F v, string format, ImGuiInputTexts flag)
11097  {
11098  byte* nativeLabel;
11099  int labelByteCount = 0;
11100  if (label != null)
11101  {
11102  labelByteCount = Encoding.UTF8.GetByteCount(label);
11103  if (labelByteCount > Util.StackAllocationSizeLimit)
11104  {
11105  nativeLabel = Util.Allocate(labelByteCount + 1);
11106  }
11107  else
11108  {
11109  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11110  nativeLabel = nativeLabelStackBytes;
11111  }
11112 
11113  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11114  nativeLabel[nativeLabelOffset] = 0;
11115  }
11116  else
11117  {
11118  nativeLabel = null;
11119  }
11120 
11121  byte* nativeFormat;
11122  int formatByteCount = 0;
11123  if (format != null)
11124  {
11125  formatByteCount = Encoding.UTF8.GetByteCount(format);
11126  if (formatByteCount > Util.StackAllocationSizeLimit)
11127  {
11128  nativeFormat = Util.Allocate(formatByteCount + 1);
11129  }
11130  else
11131  {
11132  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11133  nativeFormat = nativeFormatStackBytes;
11134  }
11135 
11136  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11137  nativeFormat[nativeFormatOffset] = 0;
11138  }
11139  else
11140  {
11141  nativeFormat = null;
11142  }
11143 
11144  fixed (Vector3F* nativeV = &v)
11145  {
11146  byte ret = ImGuiNative.igInputFloat3(nativeLabel, nativeV, nativeFormat, flag);
11147  if (labelByteCount > Util.StackAllocationSizeLimit)
11148  {
11149  Util.Free(nativeLabel);
11150  }
11151 
11152  if (formatByteCount > Util.StackAllocationSizeLimit)
11153  {
11154  Util.Free(nativeFormat);
11155  }
11156 
11157  return ret != 0;
11158  }
11159  }
11160 
11167  public static bool InputFloat4(string label, ref Vector4F v)
11168  {
11169  byte* nativeLabel;
11170  int labelByteCount = 0;
11171  if (label != null)
11172  {
11173  labelByteCount = Encoding.UTF8.GetByteCount(label);
11174  if (labelByteCount > Util.StackAllocationSizeLimit)
11175  {
11176  nativeLabel = Util.Allocate(labelByteCount + 1);
11177  }
11178  else
11179  {
11180  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11181  nativeLabel = nativeLabelStackBytes;
11182  }
11183 
11184  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11185  nativeLabel[nativeLabelOffset] = 0;
11186  }
11187  else
11188  {
11189  nativeLabel = null;
11190  }
11191 
11192  byte* nativeFormat;
11193  int formatByteCount = 0;
11194  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
11195  if (formatByteCount > Util.StackAllocationSizeLimit)
11196  {
11197  nativeFormat = Util.Allocate(formatByteCount + 1);
11198  }
11199  else
11200  {
11201  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11202  nativeFormat = nativeFormatStackBytes;
11203  }
11204 
11205  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
11206  nativeFormat[nativeFormatOffset] = 0;
11207  ImGuiInputTexts flag = 0;
11208  fixed (Vector4F* nativeV = &v)
11209  {
11210  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flag);
11211  if (labelByteCount > Util.StackAllocationSizeLimit)
11212  {
11213  Util.Free(nativeLabel);
11214  }
11215 
11216  if (formatByteCount > Util.StackAllocationSizeLimit)
11217  {
11218  Util.Free(nativeFormat);
11219  }
11220 
11221  return ret != 0;
11222  }
11223  }
11224 
11232  public static bool InputFloat4(string label, ref Vector4F v, string format)
11233  {
11234  byte* nativeLabel;
11235  int labelByteCount = 0;
11236  if (label != null)
11237  {
11238  labelByteCount = Encoding.UTF8.GetByteCount(label);
11239  if (labelByteCount > Util.StackAllocationSizeLimit)
11240  {
11241  nativeLabel = Util.Allocate(labelByteCount + 1);
11242  }
11243  else
11244  {
11245  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11246  nativeLabel = nativeLabelStackBytes;
11247  }
11248 
11249  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11250  nativeLabel[nativeLabelOffset] = 0;
11251  }
11252  else
11253  {
11254  nativeLabel = null;
11255  }
11256 
11257  byte* nativeFormat;
11258  int formatByteCount = 0;
11259  if (format != null)
11260  {
11261  formatByteCount = Encoding.UTF8.GetByteCount(format);
11262  if (formatByteCount > Util.StackAllocationSizeLimit)
11263  {
11264  nativeFormat = Util.Allocate(formatByteCount + 1);
11265  }
11266  else
11267  {
11268  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11269  nativeFormat = nativeFormatStackBytes;
11270  }
11271 
11272  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11273  nativeFormat[nativeFormatOffset] = 0;
11274  }
11275  else
11276  {
11277  nativeFormat = null;
11278  }
11279 
11280  ImGuiInputTexts flag = 0;
11281  fixed (Vector4F* nativeV = &v)
11282  {
11283  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flag);
11284  if (labelByteCount > Util.StackAllocationSizeLimit)
11285  {
11286  Util.Free(nativeLabel);
11287  }
11288 
11289  if (formatByteCount > Util.StackAllocationSizeLimit)
11290  {
11291  Util.Free(nativeFormat);
11292  }
11293 
11294  return ret != 0;
11295  }
11296  }
11297 
11306  public static bool InputFloat4(string label, ref Vector4F v, string format, ImGuiInputTexts flag)
11307  {
11308  byte* nativeLabel;
11309  int labelByteCount = 0;
11310  if (label != null)
11311  {
11312  labelByteCount = Encoding.UTF8.GetByteCount(label);
11313  if (labelByteCount > Util.StackAllocationSizeLimit)
11314  {
11315  nativeLabel = Util.Allocate(labelByteCount + 1);
11316  }
11317  else
11318  {
11319  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11320  nativeLabel = nativeLabelStackBytes;
11321  }
11322 
11323  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11324  nativeLabel[nativeLabelOffset] = 0;
11325  }
11326  else
11327  {
11328  nativeLabel = null;
11329  }
11330 
11331  byte* nativeFormat;
11332  int formatByteCount = 0;
11333  if (format != null)
11334  {
11335  formatByteCount = Encoding.UTF8.GetByteCount(format);
11336  if (formatByteCount > Util.StackAllocationSizeLimit)
11337  {
11338  nativeFormat = Util.Allocate(formatByteCount + 1);
11339  }
11340  else
11341  {
11342  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
11343  nativeFormat = nativeFormatStackBytes;
11344  }
11345 
11346  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
11347  nativeFormat[nativeFormatOffset] = 0;
11348  }
11349  else
11350  {
11351  nativeFormat = null;
11352  }
11353 
11354  fixed (Vector4F* nativeV = &v)
11355  {
11356  byte ret = ImGuiNative.igInputFloat4(nativeLabel, nativeV, nativeFormat, flag);
11357  if (labelByteCount > Util.StackAllocationSizeLimit)
11358  {
11359  Util.Free(nativeLabel);
11360  }
11361 
11362  if (formatByteCount > Util.StackAllocationSizeLimit)
11363  {
11364  Util.Free(nativeFormat);
11365  }
11366 
11367  return ret != 0;
11368  }
11369  }
11370 
11377  public static bool InputInt(string label, ref int v)
11378  {
11379  byte* nativeLabel;
11380  int labelByteCount = 0;
11381  if (label != null)
11382  {
11383  labelByteCount = Encoding.UTF8.GetByteCount(label);
11384  if (labelByteCount > Util.StackAllocationSizeLimit)
11385  {
11386  nativeLabel = Util.Allocate(labelByteCount + 1);
11387  }
11388  else
11389  {
11390  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11391  nativeLabel = nativeLabelStackBytes;
11392  }
11393 
11394  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11395  nativeLabel[nativeLabelOffset] = 0;
11396  }
11397  else
11398  {
11399  nativeLabel = null;
11400  }
11401 
11402  int step = 1;
11403  int stepFast = 100;
11404  ImGuiInputTexts flag = 0;
11405  fixed (int* nativeV = &v)
11406  {
11407  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flag);
11408  if (labelByteCount > Util.StackAllocationSizeLimit)
11409  {
11410  Util.Free(nativeLabel);
11411  }
11412 
11413  return ret != 0;
11414  }
11415  }
11416 
11424  public static bool InputInt(string label, ref int v, int step)
11425  {
11426  byte* nativeLabel;
11427  int labelByteCount = 0;
11428  if (label != null)
11429  {
11430  labelByteCount = Encoding.UTF8.GetByteCount(label);
11431  if (labelByteCount > Util.StackAllocationSizeLimit)
11432  {
11433  nativeLabel = Util.Allocate(labelByteCount + 1);
11434  }
11435  else
11436  {
11437  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11438  nativeLabel = nativeLabelStackBytes;
11439  }
11440 
11441  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11442  nativeLabel[nativeLabelOffset] = 0;
11443  }
11444  else
11445  {
11446  nativeLabel = null;
11447  }
11448 
11449  int stepFast = 100;
11450  ImGuiInputTexts flag = 0;
11451  fixed (int* nativeV = &v)
11452  {
11453  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flag);
11454  if (labelByteCount > Util.StackAllocationSizeLimit)
11455  {
11456  Util.Free(nativeLabel);
11457  }
11458 
11459  return ret != 0;
11460  }
11461  }
11462 
11471  public static bool InputInt(string label, ref int v, int step, int stepFast)
11472  {
11473  byte* nativeLabel;
11474  int labelByteCount = 0;
11475  if (label != null)
11476  {
11477  labelByteCount = Encoding.UTF8.GetByteCount(label);
11478  if (labelByteCount > Util.StackAllocationSizeLimit)
11479  {
11480  nativeLabel = Util.Allocate(labelByteCount + 1);
11481  }
11482  else
11483  {
11484  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11485  nativeLabel = nativeLabelStackBytes;
11486  }
11487 
11488  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11489  nativeLabel[nativeLabelOffset] = 0;
11490  }
11491  else
11492  {
11493  nativeLabel = null;
11494  }
11495 
11496  ImGuiInputTexts flag = 0;
11497  fixed (int* nativeV = &v)
11498  {
11499  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flag);
11500  if (labelByteCount > Util.StackAllocationSizeLimit)
11501  {
11502  Util.Free(nativeLabel);
11503  }
11504 
11505  return ret != 0;
11506  }
11507  }
11508 
11518  public static bool InputInt(string label, ref int v, int step, int stepFast, ImGuiInputTexts flag)
11519  {
11520  byte* nativeLabel;
11521  int labelByteCount = 0;
11522  if (label != null)
11523  {
11524  labelByteCount = Encoding.UTF8.GetByteCount(label);
11525  if (labelByteCount > Util.StackAllocationSizeLimit)
11526  {
11527  nativeLabel = Util.Allocate(labelByteCount + 1);
11528  }
11529  else
11530  {
11531  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11532  nativeLabel = nativeLabelStackBytes;
11533  }
11534 
11535  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11536  nativeLabel[nativeLabelOffset] = 0;
11537  }
11538  else
11539  {
11540  nativeLabel = null;
11541  }
11542 
11543  fixed (int* nativeV = &v)
11544  {
11545  byte ret = ImGuiNative.igInputInt(nativeLabel, nativeV, step, stepFast, flag);
11546  if (labelByteCount > Util.StackAllocationSizeLimit)
11547  {
11548  Util.Free(nativeLabel);
11549  }
11550 
11551  return ret != 0;
11552  }
11553  }
11554 
11561  public static bool InputInt2(string label, ref int v)
11562  {
11563  byte* nativeLabel;
11564  int labelByteCount = 0;
11565  if (label != null)
11566  {
11567  labelByteCount = Encoding.UTF8.GetByteCount(label);
11568  if (labelByteCount > Util.StackAllocationSizeLimit)
11569  {
11570  nativeLabel = Util.Allocate(labelByteCount + 1);
11571  }
11572  else
11573  {
11574  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11575  nativeLabel = nativeLabelStackBytes;
11576  }
11577 
11578  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11579  nativeLabel[nativeLabelOffset] = 0;
11580  }
11581  else
11582  {
11583  nativeLabel = null;
11584  }
11585 
11586  ImGuiInputTexts flag = 0;
11587  fixed (int* nativeV = &v)
11588  {
11589  byte ret = ImGuiNative.igInputInt2(nativeLabel, nativeV, flag);
11590  if (labelByteCount > Util.StackAllocationSizeLimit)
11591  {
11592  Util.Free(nativeLabel);
11593  }
11594 
11595  return ret != 0;
11596  }
11597  }
11598 
11606  public static bool InputInt2(string label, ref int v, ImGuiInputTexts flag)
11607  {
11608  byte* nativeLabel;
11609  int labelByteCount = 0;
11610  if (label != null)
11611  {
11612  labelByteCount = Encoding.UTF8.GetByteCount(label);
11613  if (labelByteCount > Util.StackAllocationSizeLimit)
11614  {
11615  nativeLabel = Util.Allocate(labelByteCount + 1);
11616  }
11617  else
11618  {
11619  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11620  nativeLabel = nativeLabelStackBytes;
11621  }
11622 
11623  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11624  nativeLabel[nativeLabelOffset] = 0;
11625  }
11626  else
11627  {
11628  nativeLabel = null;
11629  }
11630 
11631  fixed (int* nativeV = &v)
11632  {
11633  byte ret = ImGuiNative.igInputInt2(nativeLabel, nativeV, flag);
11634  if (labelByteCount > Util.StackAllocationSizeLimit)
11635  {
11636  Util.Free(nativeLabel);
11637  }
11638 
11639  return ret != 0;
11640  }
11641  }
11642 
11649  public static bool InputInt3(string label, ref int v)
11650  {
11651  byte* nativeLabel;
11652  int labelByteCount = 0;
11653  if (label != null)
11654  {
11655  labelByteCount = Encoding.UTF8.GetByteCount(label);
11656  if (labelByteCount > Util.StackAllocationSizeLimit)
11657  {
11658  nativeLabel = Util.Allocate(labelByteCount + 1);
11659  }
11660  else
11661  {
11662  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11663  nativeLabel = nativeLabelStackBytes;
11664  }
11665 
11666  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11667  nativeLabel[nativeLabelOffset] = 0;
11668  }
11669  else
11670  {
11671  nativeLabel = null;
11672  }
11673 
11674  ImGuiInputTexts flag = 0;
11675  fixed (int* nativeV = &v)
11676  {
11677  byte ret = ImGuiNative.igInputInt3(nativeLabel, nativeV, flag);
11678  if (labelByteCount > Util.StackAllocationSizeLimit)
11679  {
11680  Util.Free(nativeLabel);
11681  }
11682 
11683  return ret != 0;
11684  }
11685  }
11686 
11694  public static bool InputInt3(string label, ref int v, ImGuiInputTexts flag)
11695  {
11696  byte* nativeLabel;
11697  int labelByteCount = 0;
11698  if (label != null)
11699  {
11700  labelByteCount = Encoding.UTF8.GetByteCount(label);
11701  if (labelByteCount > Util.StackAllocationSizeLimit)
11702  {
11703  nativeLabel = Util.Allocate(labelByteCount + 1);
11704  }
11705  else
11706  {
11707  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11708  nativeLabel = nativeLabelStackBytes;
11709  }
11710 
11711  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11712  nativeLabel[nativeLabelOffset] = 0;
11713  }
11714  else
11715  {
11716  nativeLabel = null;
11717  }
11718 
11719  fixed (int* nativeV = &v)
11720  {
11721  byte ret = ImGuiNative.igInputInt3(nativeLabel, nativeV, flag);
11722  if (labelByteCount > Util.StackAllocationSizeLimit)
11723  {
11724  Util.Free(nativeLabel);
11725  }
11726 
11727  return ret != 0;
11728  }
11729  }
11730 
11737  public static bool InputInt4(string label, ref int v)
11738  {
11739  byte* nativeLabel;
11740  int labelByteCount = 0;
11741  if (label != null)
11742  {
11743  labelByteCount = Encoding.UTF8.GetByteCount(label);
11744  if (labelByteCount > Util.StackAllocationSizeLimit)
11745  {
11746  nativeLabel = Util.Allocate(labelByteCount + 1);
11747  }
11748  else
11749  {
11750  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11751  nativeLabel = nativeLabelStackBytes;
11752  }
11753 
11754  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11755  nativeLabel[nativeLabelOffset] = 0;
11756  }
11757  else
11758  {
11759  nativeLabel = null;
11760  }
11761 
11762  ImGuiInputTexts flag = 0;
11763  fixed (int* nativeV = &v)
11764  {
11765  byte ret = ImGuiNative.igInputInt4(nativeLabel, nativeV, flag);
11766  if (labelByteCount > Util.StackAllocationSizeLimit)
11767  {
11768  Util.Free(nativeLabel);
11769  }
11770 
11771  return ret != 0;
11772  }
11773  }
11774 
11782  public static bool InputInt4(string label, ref int v, ImGuiInputTexts flag)
11783  {
11784  byte* nativeLabel;
11785  int labelByteCount = 0;
11786  if (label != null)
11787  {
11788  labelByteCount = Encoding.UTF8.GetByteCount(label);
11789  if (labelByteCount > Util.StackAllocationSizeLimit)
11790  {
11791  nativeLabel = Util.Allocate(labelByteCount + 1);
11792  }
11793  else
11794  {
11795  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11796  nativeLabel = nativeLabelStackBytes;
11797  }
11798 
11799  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11800  nativeLabel[nativeLabelOffset] = 0;
11801  }
11802  else
11803  {
11804  nativeLabel = null;
11805  }
11806 
11807  fixed (int* nativeV = &v)
11808  {
11809  byte ret = ImGuiNative.igInputInt4(nativeLabel, nativeV, flag);
11810  if (labelByteCount > Util.StackAllocationSizeLimit)
11811  {
11812  Util.Free(nativeLabel);
11813  }
11814 
11815  return ret != 0;
11816  }
11817  }
11818 
11826  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData)
11827  {
11828  byte* nativeLabel;
11829  int labelByteCount = 0;
11830  if (label != null)
11831  {
11832  labelByteCount = Encoding.UTF8.GetByteCount(label);
11833  if (labelByteCount > Util.StackAllocationSizeLimit)
11834  {
11835  nativeLabel = Util.Allocate(labelByteCount + 1);
11836  }
11837  else
11838  {
11839  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11840  nativeLabel = nativeLabelStackBytes;
11841  }
11842 
11843  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11844  nativeLabel[nativeLabelOffset] = 0;
11845  }
11846  else
11847  {
11848  nativeLabel = null;
11849  }
11850 
11851  void* nativePData = pData.ToPointer();
11852  void* pStep = null;
11853  void* pStepFast = null;
11854  byte* nativeFormat = null;
11855  ImGuiInputTexts flag = 0;
11856  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, pStep, pStepFast, nativeFormat, flag);
11857  if (labelByteCount > Util.StackAllocationSizeLimit)
11858  {
11859  Util.Free(nativeLabel);
11860  }
11861 
11862  return ret != 0;
11863  }
11864 
11873  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep)
11874  {
11875  byte* nativeLabel;
11876  int labelByteCount = 0;
11877  if (label != null)
11878  {
11879  labelByteCount = Encoding.UTF8.GetByteCount(label);
11880  if (labelByteCount > Util.StackAllocationSizeLimit)
11881  {
11882  nativeLabel = Util.Allocate(labelByteCount + 1);
11883  }
11884  else
11885  {
11886  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11887  nativeLabel = nativeLabelStackBytes;
11888  }
11889 
11890  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11891  nativeLabel[nativeLabelOffset] = 0;
11892  }
11893  else
11894  {
11895  nativeLabel = null;
11896  }
11897 
11898  void* nativePData = pData.ToPointer();
11899  void* nativePStep = pStep.ToPointer();
11900  void* pStepFast = null;
11901  byte* nativeFormat = null;
11902  ImGuiInputTexts flag = 0;
11903  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, pStepFast, nativeFormat, flag);
11904  if (labelByteCount > Util.StackAllocationSizeLimit)
11905  {
11906  Util.Free(nativeLabel);
11907  }
11908 
11909  return ret != 0;
11910  }
11911 
11921  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast)
11922  {
11923  byte* nativeLabel;
11924  int labelByteCount = 0;
11925  if (label != null)
11926  {
11927  labelByteCount = Encoding.UTF8.GetByteCount(label);
11928  if (labelByteCount > Util.StackAllocationSizeLimit)
11929  {
11930  nativeLabel = Util.Allocate(labelByteCount + 1);
11931  }
11932  else
11933  {
11934  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11935  nativeLabel = nativeLabelStackBytes;
11936  }
11937 
11938  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11939  nativeLabel[nativeLabelOffset] = 0;
11940  }
11941  else
11942  {
11943  nativeLabel = null;
11944  }
11945 
11946  void* nativePData = pData.ToPointer();
11947  void* nativePStep = pStep.ToPointer();
11948  void* nativePStepFast = pStepFast.ToPointer();
11949  byte* nativeFormat = null;
11950  ImGuiInputTexts flag = 0;
11951  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flag);
11952  if (labelByteCount > Util.StackAllocationSizeLimit)
11953  {
11954  Util.Free(nativeLabel);
11955  }
11956 
11957  return ret != 0;
11958  }
11959 
11970  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format)
11971  {
11972  byte* nativeLabel;
11973  int labelByteCount = 0;
11974  if (label != null)
11975  {
11976  labelByteCount = Encoding.UTF8.GetByteCount(label);
11977  if (labelByteCount > Util.StackAllocationSizeLimit)
11978  {
11979  nativeLabel = Util.Allocate(labelByteCount + 1);
11980  }
11981  else
11982  {
11983  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
11984  nativeLabel = nativeLabelStackBytes;
11985  }
11986 
11987  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
11988  nativeLabel[nativeLabelOffset] = 0;
11989  }
11990  else
11991  {
11992  nativeLabel = null;
11993  }
11994 
11995  void* nativePData = pData.ToPointer();
11996  void* nativePStep = pStep.ToPointer();
11997  void* nativePStepFast = pStepFast.ToPointer();
11998  byte* nativeFormat;
11999  int formatByteCount = 0;
12000  if (format != null)
12001  {
12002  formatByteCount = Encoding.UTF8.GetByteCount(format);
12003  if (formatByteCount > Util.StackAllocationSizeLimit)
12004  {
12005  nativeFormat = Util.Allocate(formatByteCount + 1);
12006  }
12007  else
12008  {
12009  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12010  nativeFormat = nativeFormatStackBytes;
12011  }
12012 
12013  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12014  nativeFormat[nativeFormatOffset] = 0;
12015  }
12016  else
12017  {
12018  nativeFormat = null;
12019  }
12020 
12021  ImGuiInputTexts flag = 0;
12022  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flag);
12023  if (labelByteCount > Util.StackAllocationSizeLimit)
12024  {
12025  Util.Free(nativeLabel);
12026  }
12027 
12028  if (formatByteCount > Util.StackAllocationSizeLimit)
12029  {
12030  Util.Free(nativeFormat);
12031  }
12032 
12033  return ret != 0;
12034  }
12035 
12047  public static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTexts flag)
12048  {
12049  byte* nativeLabel;
12050  int labelByteCount = 0;
12051  if (label != null)
12052  {
12053  labelByteCount = Encoding.UTF8.GetByteCount(label);
12054  if (labelByteCount > Util.StackAllocationSizeLimit)
12055  {
12056  nativeLabel = Util.Allocate(labelByteCount + 1);
12057  }
12058  else
12059  {
12060  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12061  nativeLabel = nativeLabelStackBytes;
12062  }
12063 
12064  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12065  nativeLabel[nativeLabelOffset] = 0;
12066  }
12067  else
12068  {
12069  nativeLabel = null;
12070  }
12071 
12072  void* nativePData = pData.ToPointer();
12073  void* nativePStep = pStep.ToPointer();
12074  void* nativePStepFast = pStepFast.ToPointer();
12075  byte* nativeFormat;
12076  int formatByteCount = 0;
12077  if (format != null)
12078  {
12079  formatByteCount = Encoding.UTF8.GetByteCount(format);
12080  if (formatByteCount > Util.StackAllocationSizeLimit)
12081  {
12082  nativeFormat = Util.Allocate(formatByteCount + 1);
12083  }
12084  else
12085  {
12086  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12087  nativeFormat = nativeFormatStackBytes;
12088  }
12089 
12090  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12091  nativeFormat[nativeFormatOffset] = 0;
12092  }
12093  else
12094  {
12095  nativeFormat = null;
12096  }
12097 
12098  byte ret = ImGuiNative.igInputScalar(nativeLabel, dataType, nativePData, nativePStep, nativePStepFast, nativeFormat, flag);
12099  if (labelByteCount > Util.StackAllocationSizeLimit)
12100  {
12101  Util.Free(nativeLabel);
12102  }
12103 
12104  if (formatByteCount > Util.StackAllocationSizeLimit)
12105  {
12106  Util.Free(nativeFormat);
12107  }
12108 
12109  return ret != 0;
12110  }
12111 
12120  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
12121  {
12122  byte* nativeLabel;
12123  int labelByteCount = 0;
12124  if (label != null)
12125  {
12126  labelByteCount = Encoding.UTF8.GetByteCount(label);
12127  if (labelByteCount > Util.StackAllocationSizeLimit)
12128  {
12129  nativeLabel = Util.Allocate(labelByteCount + 1);
12130  }
12131  else
12132  {
12133  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12134  nativeLabel = nativeLabelStackBytes;
12135  }
12136 
12137  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12138  nativeLabel[nativeLabelOffset] = 0;
12139  }
12140  else
12141  {
12142  nativeLabel = null;
12143  }
12144 
12145  void* nativePData = pData.ToPointer();
12146  void* pStep = null;
12147  void* pStepFast = null;
12148  byte* nativeFormat = null;
12149  ImGuiInputTexts flag = 0;
12150  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, pStep, pStepFast, nativeFormat, flag);
12151  if (labelByteCount > Util.StackAllocationSizeLimit)
12152  {
12153  Util.Free(nativeLabel);
12154  }
12155 
12156  return ret != 0;
12157  }
12158 
12168  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep)
12169  {
12170  byte* nativeLabel;
12171  int labelByteCount = 0;
12172  if (label != null)
12173  {
12174  labelByteCount = Encoding.UTF8.GetByteCount(label);
12175  if (labelByteCount > Util.StackAllocationSizeLimit)
12176  {
12177  nativeLabel = Util.Allocate(labelByteCount + 1);
12178  }
12179  else
12180  {
12181  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12182  nativeLabel = nativeLabelStackBytes;
12183  }
12184 
12185  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12186  nativeLabel[nativeLabelOffset] = 0;
12187  }
12188  else
12189  {
12190  nativeLabel = null;
12191  }
12192 
12193  void* nativePData = pData.ToPointer();
12194  void* nativePStep = pStep.ToPointer();
12195  void* pStepFast = null;
12196  byte* nativeFormat = null;
12197  ImGuiInputTexts flag = 0;
12198  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, pStepFast, nativeFormat, flag);
12199  if (labelByteCount > Util.StackAllocationSizeLimit)
12200  {
12201  Util.Free(nativeLabel);
12202  }
12203 
12204  return ret != 0;
12205  }
12206 
12217  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast)
12218  {
12219  byte* nativeLabel;
12220  int labelByteCount = 0;
12221  if (label != null)
12222  {
12223  labelByteCount = Encoding.UTF8.GetByteCount(label);
12224  if (labelByteCount > Util.StackAllocationSizeLimit)
12225  {
12226  nativeLabel = Util.Allocate(labelByteCount + 1);
12227  }
12228  else
12229  {
12230  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12231  nativeLabel = nativeLabelStackBytes;
12232  }
12233 
12234  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12235  nativeLabel[nativeLabelOffset] = 0;
12236  }
12237  else
12238  {
12239  nativeLabel = null;
12240  }
12241 
12242  void* nativePData = pData.ToPointer();
12243  void* nativePStep = pStep.ToPointer();
12244  void* nativePStepFast = pStepFast.ToPointer();
12245  byte* nativeFormat = null;
12246  ImGuiInputTexts flag = 0;
12247  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flag);
12248  if (labelByteCount > Util.StackAllocationSizeLimit)
12249  {
12250  Util.Free(nativeLabel);
12251  }
12252 
12253  return ret != 0;
12254  }
12255 
12267  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format)
12268  {
12269  byte* nativeLabel;
12270  int labelByteCount = 0;
12271  if (label != null)
12272  {
12273  labelByteCount = Encoding.UTF8.GetByteCount(label);
12274  if (labelByteCount > Util.StackAllocationSizeLimit)
12275  {
12276  nativeLabel = Util.Allocate(labelByteCount + 1);
12277  }
12278  else
12279  {
12280  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12281  nativeLabel = nativeLabelStackBytes;
12282  }
12283 
12284  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12285  nativeLabel[nativeLabelOffset] = 0;
12286  }
12287  else
12288  {
12289  nativeLabel = null;
12290  }
12291 
12292  void* nativePData = pData.ToPointer();
12293  void* nativePStep = pStep.ToPointer();
12294  void* nativePStepFast = pStepFast.ToPointer();
12295  byte* nativeFormat;
12296  int formatByteCount = 0;
12297  if (format != null)
12298  {
12299  formatByteCount = Encoding.UTF8.GetByteCount(format);
12300  if (formatByteCount > Util.StackAllocationSizeLimit)
12301  {
12302  nativeFormat = Util.Allocate(formatByteCount + 1);
12303  }
12304  else
12305  {
12306  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12307  nativeFormat = nativeFormatStackBytes;
12308  }
12309 
12310  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12311  nativeFormat[nativeFormatOffset] = 0;
12312  }
12313  else
12314  {
12315  nativeFormat = null;
12316  }
12317 
12318  ImGuiInputTexts flag = 0;
12319  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flag);
12320  if (labelByteCount > Util.StackAllocationSizeLimit)
12321  {
12322  Util.Free(nativeLabel);
12323  }
12324 
12325  if (formatByteCount > Util.StackAllocationSizeLimit)
12326  {
12327  Util.Free(nativeFormat);
12328  }
12329 
12330  return ret != 0;
12331  }
12332 
12345  public static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTexts flag)
12346  {
12347  byte* nativeLabel;
12348  int labelByteCount = 0;
12349  if (label != null)
12350  {
12351  labelByteCount = Encoding.UTF8.GetByteCount(label);
12352  if (labelByteCount > Util.StackAllocationSizeLimit)
12353  {
12354  nativeLabel = Util.Allocate(labelByteCount + 1);
12355  }
12356  else
12357  {
12358  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
12359  nativeLabel = nativeLabelStackBytes;
12360  }
12361 
12362  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
12363  nativeLabel[nativeLabelOffset] = 0;
12364  }
12365  else
12366  {
12367  nativeLabel = null;
12368  }
12369 
12370  void* nativePData = pData.ToPointer();
12371  void* nativePStep = pStep.ToPointer();
12372  void* nativePStepFast = pStepFast.ToPointer();
12373  byte* nativeFormat;
12374  int formatByteCount = 0;
12375  if (format != null)
12376  {
12377  formatByteCount = Encoding.UTF8.GetByteCount(format);
12378  if (formatByteCount > Util.StackAllocationSizeLimit)
12379  {
12380  nativeFormat = Util.Allocate(formatByteCount + 1);
12381  }
12382  else
12383  {
12384  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
12385  nativeFormat = nativeFormatStackBytes;
12386  }
12387 
12388  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
12389  nativeFormat[nativeFormatOffset] = 0;
12390  }
12391  else
12392  {
12393  nativeFormat = null;
12394  }
12395 
12396  byte ret = ImGuiNative.igInputScalarN(nativeLabel, dataType, nativePData, components, nativePStep, nativePStepFast, nativeFormat, flag);
12397  if (labelByteCount > Util.StackAllocationSizeLimit)
12398  {
12399  Util.Free(nativeLabel);
12400  }
12401 
12402  if (formatByteCount > Util.StackAllocationSizeLimit)
12403  {
12404  Util.Free(nativeFormat);
12405  }
12406 
12407  return ret != 0;
12408  }
12409 
12416  public static bool InvisibleButton(string strId, Vector2F size)
12417  {
12418  byte* nativeStrId;
12419  int strIdByteCount = 0;
12420  if (strId != null)
12421  {
12422  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12423  if (strIdByteCount > Util.StackAllocationSizeLimit)
12424  {
12425  nativeStrId = Util.Allocate(strIdByteCount + 1);
12426  }
12427  else
12428  {
12429  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12430  nativeStrId = nativeStrIdStackBytes;
12431  }
12432 
12433  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12434  nativeStrId[nativeStrIdOffset] = 0;
12435  }
12436  else
12437  {
12438  nativeStrId = null;
12439  }
12440 
12441  ImGuiButtons flag = 0;
12442  byte ret = ImGuiNative.igInvisibleButton(nativeStrId, size, flag);
12443  if (strIdByteCount > Util.StackAllocationSizeLimit)
12444  {
12445  Util.Free(nativeStrId);
12446  }
12447 
12448  return ret != 0;
12449  }
12450 
12458  public static bool InvisibleButton(string strId, Vector2F size, ImGuiButtons flag)
12459  {
12460  byte* nativeStrId;
12461  int strIdByteCount = 0;
12462  if (strId != null)
12463  {
12464  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12465  if (strIdByteCount > Util.StackAllocationSizeLimit)
12466  {
12467  nativeStrId = Util.Allocate(strIdByteCount + 1);
12468  }
12469  else
12470  {
12471  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12472  nativeStrId = nativeStrIdStackBytes;
12473  }
12474 
12475  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12476  nativeStrId[nativeStrIdOffset] = 0;
12477  }
12478  else
12479  {
12480  nativeStrId = null;
12481  }
12482 
12483  byte ret = ImGuiNative.igInvisibleButton(nativeStrId, size, flag);
12484  if (strIdByteCount > Util.StackAllocationSizeLimit)
12485  {
12486  Util.Free(nativeStrId);
12487  }
12488 
12489  return ret != 0;
12490  }
12491 
12496  public static bool IsAnyItemActive()
12497  {
12498  byte ret = ImGuiNative.igIsAnyItemActive();
12499  return ret != 0;
12500  }
12501 
12506  public static bool IsAnyItemFocused()
12507  {
12508  byte ret = ImGuiNative.igIsAnyItemFocused();
12509  return ret != 0;
12510  }
12511 
12516  public static bool IsAnyItemHovered()
12517  {
12518  byte ret = ImGuiNative.igIsAnyItemHovered();
12519  return ret != 0;
12520  }
12521 
12526  public static bool IsAnyMouseDown()
12527  {
12528  byte ret = ImGuiNative.igIsAnyMouseDown();
12529  return ret != 0;
12530  }
12531 
12536  public static bool IsItemActivated()
12537  {
12538  byte ret = ImGuiNative.igIsItemActivated();
12539  return ret != 0;
12540  }
12541 
12546  public static bool IsItemActive()
12547  {
12548  byte ret = ImGuiNative.igIsItemActive();
12549  return ret != 0;
12550  }
12551 
12556  public static bool IsItemClicked()
12557  {
12558  ImGuiMouseButton mouseButton = 0;
12559  byte ret = ImGuiNative.igIsItemClicked(mouseButton);
12560  return ret != 0;
12561  }
12562 
12568  public static bool IsItemClicked(ImGuiMouseButton mouseButton)
12569  {
12570  byte ret = ImGuiNative.igIsItemClicked(mouseButton);
12571  return ret != 0;
12572  }
12573 
12578  public static bool IsItemDeactivated()
12579  {
12580  byte ret = ImGuiNative.igIsItemDeactivated();
12581  return ret != 0;
12582  }
12583 
12588  public static bool IsItemDeactivatedAfterEdit()
12589  {
12591  return ret != 0;
12592  }
12593 
12598  public static bool IsItemEdited()
12599  {
12600  byte ret = ImGuiNative.igIsItemEdited();
12601  return ret != 0;
12602  }
12603 
12608  public static bool IsItemFocused()
12609  {
12610  byte ret = ImGuiNative.igIsItemFocused();
12611  return ret != 0;
12612  }
12613 
12618  public static bool IsItemHovered()
12619  {
12620  ImGuiHovereds flag = 0;
12621  byte ret = ImGuiNative.igIsItemHovered(flag);
12622  return ret != 0;
12623  }
12624 
12630  public static bool IsItemHovered(ImGuiHovereds flag)
12631  {
12632  byte ret = ImGuiNative.igIsItemHovered(flag);
12633  return ret != 0;
12634  }
12635 
12640  public static bool IsItemToggledOpen()
12641  {
12642  byte ret = ImGuiNative.igIsItemToggledOpen();
12643  return ret != 0;
12644  }
12645 
12650  public static bool IsItemVisible()
12651  {
12652  byte ret = ImGuiNative.igIsItemVisible();
12653  return ret != 0;
12654  }
12655 
12661  public static bool IsKeyDown(ImGuiKey key)
12662  {
12663  byte ret = ImGuiNative.igIsKeyDown_Nil(key);
12664  return ret != 0;
12665  }
12666 
12672  public static bool IsKeyPressed(ImGuiKey key)
12673  {
12674  byte repeat = 1;
12675  byte ret = ImGuiNative.igIsKeyPressed_Bool(key, repeat);
12676  return ret != 0;
12677  }
12678 
12685  public static bool IsKeyPressed(ImGuiKey key, bool repeat)
12686  {
12687  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
12688  byte ret = ImGuiNative.igIsKeyPressed_Bool(key, nativeRepeat);
12689  return ret != 0;
12690  }
12691 
12697  public static bool IsKeyReleased(ImGuiKey key)
12698  {
12699  byte ret = ImGuiNative.igIsKeyReleased_Nil(key);
12700  return ret != 0;
12701  }
12702 
12708  public static bool IsMouseClicked(ImGuiMouseButton button)
12709  {
12710  byte repeat = 0;
12711  byte ret = ImGuiNative.igIsMouseClicked_Bool(button, repeat);
12712  return ret != 0;
12713  }
12714 
12721  public static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
12722  {
12723  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
12724  byte ret = ImGuiNative.igIsMouseClicked_Bool(button, nativeRepeat);
12725  return ret != 0;
12726  }
12727 
12733  public static bool IsMouseDoubleClicked(ImGuiMouseButton button)
12734  {
12735  byte ret = ImGuiNative.igIsMouseDoubleClicked(button);
12736  return ret != 0;
12737  }
12738 
12744  public static bool IsMouseDown(ImGuiMouseButton button)
12745  {
12746  byte ret = ImGuiNative.igIsMouseDown_Nil(button);
12747  return ret != 0;
12748  }
12749 
12755  public static bool IsMouseDragging(ImGuiMouseButton button)
12756  {
12757  float lockThreshold = -1.0f;
12758  byte ret = ImGuiNative.igIsMouseDragging(button, lockThreshold);
12759  return ret != 0;
12760  }
12761 
12768  public static bool IsMouseDragging(ImGuiMouseButton button, float lockThreshold)
12769  {
12770  byte ret = ImGuiNative.igIsMouseDragging(button, lockThreshold);
12771  return ret != 0;
12772  }
12773 
12780  public static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax)
12781  {
12782  byte clip = 1;
12783  byte ret = ImGuiNative.igIsMouseHoveringRect(rMin, rMax, clip);
12784  return ret != 0;
12785  }
12786 
12794  public static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax, bool clip)
12795  {
12796  byte nativeClip = clip ? (byte) 1 : (byte) 0;
12797  byte ret = ImGuiNative.igIsMouseHoveringRect(rMin, rMax, nativeClip);
12798  return ret != 0;
12799  }
12800 
12805  public static bool IsMousePosValid()
12806  {
12807  Vector2F* mousePos = null;
12808  byte ret = ImGuiNative.igIsMousePosValid(mousePos);
12809  return ret != 0;
12810  }
12811 
12817  public static bool IsMousePosValid(ref Vector2F mousePos)
12818  {
12819  fixed (Vector2F* nativeMousePos = &mousePos)
12820  {
12821  byte ret = ImGuiNative.igIsMousePosValid(nativeMousePos);
12822  return ret != 0;
12823  }
12824  }
12825 
12831  public static bool IsMouseReleased(ImGuiMouseButton button)
12832  {
12833  byte ret = ImGuiNative.igIsMouseReleased_Nil(button);
12834  return ret != 0;
12835  }
12836 
12842  public static bool IsPopupOpen(string strId)
12843  {
12844  byte* nativeStrId;
12845  int strIdByteCount = 0;
12846  if (strId != null)
12847  {
12848  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12849  if (strIdByteCount > Util.StackAllocationSizeLimit)
12850  {
12851  nativeStrId = Util.Allocate(strIdByteCount + 1);
12852  }
12853  else
12854  {
12855  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12856  nativeStrId = nativeStrIdStackBytes;
12857  }
12858 
12859  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12860  nativeStrId[nativeStrIdOffset] = 0;
12861  }
12862  else
12863  {
12864  nativeStrId = null;
12865  }
12866 
12867  ImGuiPopups flag = 0;
12868  byte ret = ImGuiNative.igIsPopupOpen_Str(nativeStrId, flag);
12869  if (strIdByteCount > Util.StackAllocationSizeLimit)
12870  {
12871  Util.Free(nativeStrId);
12872  }
12873 
12874  return ret != 0;
12875  }
12876 
12883  public static bool IsPopupOpen(string strId, ImGuiPopups flag)
12884  {
12885  byte* nativeStrId;
12886  int strIdByteCount = 0;
12887  if (strId != null)
12888  {
12889  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
12890  if (strIdByteCount > Util.StackAllocationSizeLimit)
12891  {
12892  nativeStrId = Util.Allocate(strIdByteCount + 1);
12893  }
12894  else
12895  {
12896  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
12897  nativeStrId = nativeStrIdStackBytes;
12898  }
12899 
12900  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
12901  nativeStrId[nativeStrIdOffset] = 0;
12902  }
12903  else
12904  {
12905  nativeStrId = null;
12906  }
12907 
12908  byte ret = ImGuiNative.igIsPopupOpen_Str(nativeStrId, flag);
12909  if (strIdByteCount > Util.StackAllocationSizeLimit)
12910  {
12911  Util.Free(nativeStrId);
12912  }
12913 
12914  return ret != 0;
12915  }
12916 
12922  public static bool IsRectVisible(Vector2F size)
12923  {
12924  byte ret = ImGuiNative.igIsRectVisible_Nil(size);
12925  return ret != 0;
12926  }
12927 
12934  public static bool IsRectVisible(Vector2F rectMin, Vector2F rectMax)
12935  {
12936  byte ret = ImGuiNative.igIsRectVisible_Vec2(rectMin, rectMax);
12937  return ret != 0;
12938  }
12939 
12944  public static bool IsWindowAppearing()
12945  {
12946  byte ret = ImGuiNative.igIsWindowAppearing();
12947  return ret != 0;
12948  }
12949 
12954  public static bool IsWindowCollapsed()
12955  {
12956  byte ret = ImGuiNative.igIsWindowCollapsed();
12957  return ret != 0;
12958  }
12959 
12964  public static bool IsWindowDocked()
12965  {
12966  byte ret = ImGuiNative.igIsWindowDocked();
12967  return ret != 0;
12968  }
12969 
12974  public static bool IsWindowFocused()
12975  {
12976  ImGuiFocus flag = 0;
12977  byte ret = ImGuiNative.igIsWindowFocused(flag);
12978  return ret != 0;
12979  }
12980 
12986  public static bool IsWindowFocused(ImGuiFocus flag)
12987  {
12988  byte ret = ImGuiNative.igIsWindowFocused(flag);
12989  return ret != 0;
12990  }
12991 
12996  public static bool IsWindowHovered()
12997  {
12998  ImGuiHovereds flag = 0;
12999  byte ret = ImGuiNative.igIsWindowHovered(flag);
13000  return ret != 0;
13001  }
13002 
13008  public static bool IsWindowHovered(ImGuiHovereds flag)
13009  {
13010  byte ret = ImGuiNative.igIsWindowHovered(flag);
13011  return ret != 0;
13012  }
13013 
13019  public static void LabelText(string label, string fmt)
13020  {
13021  byte* nativeLabel;
13022  int labelByteCount = 0;
13023  if (label != null)
13024  {
13025  labelByteCount = Encoding.UTF8.GetByteCount(label);
13026  if (labelByteCount > Util.StackAllocationSizeLimit)
13027  {
13028  nativeLabel = Util.Allocate(labelByteCount + 1);
13029  }
13030  else
13031  {
13032  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13033  nativeLabel = nativeLabelStackBytes;
13034  }
13035 
13036  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13037  nativeLabel[nativeLabelOffset] = 0;
13038  }
13039  else
13040  {
13041  nativeLabel = null;
13042  }
13043 
13044  byte* nativeFmt;
13045  int fmtByteCount = 0;
13046  if (fmt != null)
13047  {
13048  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13049  if (fmtByteCount > Util.StackAllocationSizeLimit)
13050  {
13051  nativeFmt = Util.Allocate(fmtByteCount + 1);
13052  }
13053  else
13054  {
13055  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
13056  nativeFmt = nativeFmtStackBytes;
13057  }
13058 
13059  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
13060  nativeFmt[nativeFmtOffset] = 0;
13061  }
13062  else
13063  {
13064  nativeFmt = null;
13065  }
13066 
13067  ImGuiNative.igLabelText(nativeLabel, nativeFmt);
13068  if (labelByteCount > Util.StackAllocationSizeLimit)
13069  {
13070  Util.Free(nativeLabel);
13071  }
13072 
13073  if (fmtByteCount > Util.StackAllocationSizeLimit)
13074  {
13075  Util.Free(nativeFmt);
13076  }
13077  }
13078 
13087  public static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount)
13088  {
13089  byte* nativeLabel;
13090  int labelByteCount = 0;
13091  if (label != null)
13092  {
13093  labelByteCount = Encoding.UTF8.GetByteCount(label);
13094  if (labelByteCount > Util.StackAllocationSizeLimit)
13095  {
13096  nativeLabel = Util.Allocate(labelByteCount + 1);
13097  }
13098  else
13099  {
13100  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13101  nativeLabel = nativeLabelStackBytes;
13102  }
13103 
13104  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13105  nativeLabel[nativeLabelOffset] = 0;
13106  }
13107  else
13108  {
13109  nativeLabel = null;
13110  }
13111 
13112  int* itemsByteCounts = stackalloc int[items.Length];
13113  int itemsByteCount = 0;
13114  for (int i = 0; i < items.Length; i++)
13115  {
13116  string s = items[i];
13117  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13118  itemsByteCount += itemsByteCounts[i] + 1;
13119  }
13120 
13121  byte* nativeItemsData = stackalloc byte[itemsByteCount];
13122  int offset = 0;
13123  for (int i = 0; i < items.Length; i++)
13124  {
13125  string s = items[i];
13126  fixed (char* sPtr = s)
13127  {
13128  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13129  nativeItemsData[offset] = 0;
13130  offset += 1;
13131  }
13132  }
13133 
13134  byte** nativeItems = stackalloc byte*[items.Length];
13135  offset = 0;
13136  for (int i = 0; i < items.Length; i++)
13137  {
13138  nativeItems[i] = &nativeItemsData[offset];
13139  offset += itemsByteCounts[i] + 1;
13140  }
13141 
13142  int heightInItems = -1;
13143  fixed (int* nativeCurrentItem = &currentItem)
13144  {
13145  byte ret = ImGuiNative.igListBox_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, heightInItems);
13146  if (labelByteCount > Util.StackAllocationSizeLimit)
13147  {
13148  Util.Free(nativeLabel);
13149  }
13150 
13151  return ret != 0;
13152  }
13153  }
13154 
13164  public static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount, int heightInItems)
13165  {
13166  byte* nativeLabel;
13167  int labelByteCount = 0;
13168  if (label != null)
13169  {
13170  labelByteCount = Encoding.UTF8.GetByteCount(label);
13171  if (labelByteCount > Util.StackAllocationSizeLimit)
13172  {
13173  nativeLabel = Util.Allocate(labelByteCount + 1);
13174  }
13175  else
13176  {
13177  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13178  nativeLabel = nativeLabelStackBytes;
13179  }
13180 
13181  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13182  nativeLabel[nativeLabelOffset] = 0;
13183  }
13184  else
13185  {
13186  nativeLabel = null;
13187  }
13188 
13189  int* itemsByteCounts = stackalloc int[items.Length];
13190  int itemsByteCount = 0;
13191  for (int i = 0; i < items.Length; i++)
13192  {
13193  string s = items[i];
13194  itemsByteCounts[i] = Encoding.UTF8.GetByteCount(s);
13195  itemsByteCount += itemsByteCounts[i] + 1;
13196  }
13197 
13198  byte* nativeItemsData = stackalloc byte[itemsByteCount];
13199  int offset = 0;
13200  for (int i = 0; i < items.Length; i++)
13201  {
13202  string s = items[i];
13203  fixed (char* sPtr = s)
13204  {
13205  offset += Encoding.UTF8.GetBytes(sPtr, s.Length, nativeItemsData + offset, itemsByteCounts[i]);
13206  nativeItemsData[offset] = 0;
13207  offset += 1;
13208  }
13209  }
13210 
13211  byte** nativeItems = stackalloc byte*[items.Length];
13212  offset = 0;
13213  for (int i = 0; i < items.Length; i++)
13214  {
13215  nativeItems[i] = &nativeItemsData[offset];
13216  offset += itemsByteCounts[i] + 1;
13217  }
13218 
13219  fixed (int* nativeCurrentItem = &currentItem)
13220  {
13221  byte ret = ImGuiNative.igListBox_Str_arr(nativeLabel, nativeCurrentItem, nativeItems, itemsCount, heightInItems);
13222  if (labelByteCount > Util.StackAllocationSizeLimit)
13223  {
13224  Util.Free(nativeLabel);
13225  }
13226 
13227  return ret != 0;
13228  }
13229  }
13230 
13235  public static void LoadIniSettingsFromDisk(string iniFilename)
13236  {
13237  byte* nativeIniFilename;
13238  int iniFilenameByteCount = 0;
13239  if (iniFilename != null)
13240  {
13241  iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
13242  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
13243  {
13244  nativeIniFilename = Util.Allocate(iniFilenameByteCount + 1);
13245  }
13246  else
13247  {
13248  byte* nativeIniFilenameStackBytes = stackalloc byte[iniFilenameByteCount + 1];
13249  nativeIniFilename = nativeIniFilenameStackBytes;
13250  }
13251 
13252  int nativeIniFilenameOffset = Util.GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
13253  nativeIniFilename[nativeIniFilenameOffset] = 0;
13254  }
13255  else
13256  {
13257  nativeIniFilename = null;
13258  }
13259 
13260  ImGuiNative.igLoadIniSettingsFromDisk(nativeIniFilename);
13261  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
13262  {
13263  Util.Free(nativeIniFilename);
13264  }
13265  }
13266 
13271  public static void LoadIniSettingsFromMemory(string iniData)
13272  {
13273  byte* nativeIniData;
13274  int iniDataByteCount = 0;
13275  if (iniData != null)
13276  {
13277  iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13278  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13279  {
13280  nativeIniData = Util.Allocate(iniDataByteCount + 1);
13281  }
13282  else
13283  {
13284  byte* nativeIniDataStackBytes = stackalloc byte[iniDataByteCount + 1];
13285  nativeIniData = nativeIniDataStackBytes;
13286  }
13287 
13288  int nativeIniDataOffset = Util.GetUtf8(iniData, nativeIniData, iniDataByteCount);
13289  nativeIniData[nativeIniDataOffset] = 0;
13290  }
13291  else
13292  {
13293  nativeIniData = null;
13294  }
13295 
13296  uint iniSize = 0;
13297  ImGuiNative.igLoadIniSettingsFromMemory(nativeIniData, iniSize);
13298  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13299  {
13300  Util.Free(nativeIniData);
13301  }
13302  }
13303 
13309  public static void LoadIniSettingsFromMemory(string iniData, uint iniSize)
13310  {
13311  byte* nativeIniData;
13312  int iniDataByteCount = 0;
13313  if (iniData != null)
13314  {
13315  iniDataByteCount = Encoding.UTF8.GetByteCount(iniData);
13316  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13317  {
13318  nativeIniData = Util.Allocate(iniDataByteCount + 1);
13319  }
13320  else
13321  {
13322  byte* nativeIniDataStackBytes = stackalloc byte[iniDataByteCount + 1];
13323  nativeIniData = nativeIniDataStackBytes;
13324  }
13325 
13326  int nativeIniDataOffset = Util.GetUtf8(iniData, nativeIniData, iniDataByteCount);
13327  nativeIniData[nativeIniDataOffset] = 0;
13328  }
13329  else
13330  {
13331  nativeIniData = null;
13332  }
13333 
13334  ImGuiNative.igLoadIniSettingsFromMemory(nativeIniData, iniSize);
13335  if (iniDataByteCount > Util.StackAllocationSizeLimit)
13336  {
13337  Util.Free(nativeIniData);
13338  }
13339  }
13340 
13344  public static void LogButtons()
13345  {
13347  }
13348 
13352  public static void LogFinish()
13353  {
13355  }
13356 
13361  public static void LogText(string fmt)
13362  {
13363  byte* nativeFmt;
13364  int fmtByteCount = 0;
13365  if (fmt != null)
13366  {
13367  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
13368  if (fmtByteCount > Util.StackAllocationSizeLimit)
13369  {
13370  nativeFmt = Util.Allocate(fmtByteCount + 1);
13371  }
13372  else
13373  {
13374  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
13375  nativeFmt = nativeFmtStackBytes;
13376  }
13377 
13378  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
13379  nativeFmt[nativeFmtOffset] = 0;
13380  }
13381  else
13382  {
13383  nativeFmt = null;
13384  }
13385 
13386  ImGuiNative.igLogText(nativeFmt);
13387  if (fmtByteCount > Util.StackAllocationSizeLimit)
13388  {
13389  Util.Free(nativeFmt);
13390  }
13391  }
13392 
13396  public static void LogToClipboard()
13397  {
13398  int autoOpenDepth = -1;
13399  ImGuiNative.igLogToClipboard(autoOpenDepth);
13400  }
13401 
13406  public static void LogToClipboard(int autoOpenDepth)
13407  {
13408  ImGuiNative.igLogToClipboard(autoOpenDepth);
13409  }
13410 
13414  public static void LogToFile()
13415  {
13416  int autoOpenDepth = -1;
13417  byte* nativeFilename = null;
13418  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13419  }
13420 
13425  public static void LogToFile(int autoOpenDepth)
13426  {
13427  byte* nativeFilename = null;
13428  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13429  }
13430 
13436  public static void LogToFile(int autoOpenDepth, string filename)
13437  {
13438  byte* nativeFilename;
13439  int filenameByteCount = 0;
13440  if (filename != null)
13441  {
13442  filenameByteCount = Encoding.UTF8.GetByteCount(filename);
13443  if (filenameByteCount > Util.StackAllocationSizeLimit)
13444  {
13445  nativeFilename = Util.Allocate(filenameByteCount + 1);
13446  }
13447  else
13448  {
13449  byte* nativeFilenameStackBytes = stackalloc byte[filenameByteCount + 1];
13450  nativeFilename = nativeFilenameStackBytes;
13451  }
13452 
13453  int nativeFilenameOffset = Util.GetUtf8(filename, nativeFilename, filenameByteCount);
13454  nativeFilename[nativeFilenameOffset] = 0;
13455  }
13456  else
13457  {
13458  nativeFilename = null;
13459  }
13460 
13461  ImGuiNative.igLogToFile(autoOpenDepth, nativeFilename);
13462  if (filenameByteCount > Util.StackAllocationSizeLimit)
13463  {
13464  Util.Free(nativeFilename);
13465  }
13466  }
13467 
13471  public static void LogToTty()
13472  {
13473  int autoOpenDepth = -1;
13474  ImGuiNative.igLogToTTY(autoOpenDepth);
13475  }
13476 
13481  public static void LogToTty(int autoOpenDepth)
13482  {
13483  ImGuiNative.igLogToTTY(autoOpenDepth);
13484  }
13485 
13491  public static IntPtr MemAlloc(uint size)
13492  {
13493  void* ret = ImGuiNative.igMemAlloc(size);
13494  return (IntPtr) ret;
13495  }
13496 
13501  public static void MemFree(IntPtr ptr)
13502  {
13503  void* nativePtr = ptr.ToPointer();
13504  ImGuiNative.igMemFree(nativePtr);
13505  }
13506 
13512  public static bool MenuItem(string label)
13513  {
13514  byte* nativeLabel;
13515  int labelByteCount = 0;
13516  if (label != null)
13517  {
13518  labelByteCount = Encoding.UTF8.GetByteCount(label);
13519  if (labelByteCount > Util.StackAllocationSizeLimit)
13520  {
13521  nativeLabel = Util.Allocate(labelByteCount + 1);
13522  }
13523  else
13524  {
13525  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13526  nativeLabel = nativeLabelStackBytes;
13527  }
13528 
13529  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13530  nativeLabel[nativeLabelOffset] = 0;
13531  }
13532  else
13533  {
13534  nativeLabel = null;
13535  }
13536 
13537  byte* nativeShortcut = null;
13538  byte selected = 0;
13539  byte enabled = 1;
13540  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, selected, enabled);
13541  if (labelByteCount > Util.StackAllocationSizeLimit)
13542  {
13543  Util.Free(nativeLabel);
13544  }
13545 
13546  return ret != 0;
13547  }
13548 
13555  public static bool MenuItem(string label, string shortcut)
13556  {
13557  byte* nativeLabel;
13558  int labelByteCount = 0;
13559  if (label != null)
13560  {
13561  labelByteCount = Encoding.UTF8.GetByteCount(label);
13562  if (labelByteCount > Util.StackAllocationSizeLimit)
13563  {
13564  nativeLabel = Util.Allocate(labelByteCount + 1);
13565  }
13566  else
13567  {
13568  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13569  nativeLabel = nativeLabelStackBytes;
13570  }
13571 
13572  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13573  nativeLabel[nativeLabelOffset] = 0;
13574  }
13575  else
13576  {
13577  nativeLabel = null;
13578  }
13579 
13580  byte* nativeShortcut;
13581  int shortcutByteCount = 0;
13582  if (shortcut != null)
13583  {
13584  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13585  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13586  {
13587  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13588  }
13589  else
13590  {
13591  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13592  nativeShortcut = nativeShortcutStackBytes;
13593  }
13594 
13595  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13596  nativeShortcut[nativeShortcutOffset] = 0;
13597  }
13598  else
13599  {
13600  nativeShortcut = null;
13601  }
13602 
13603  byte selected = 0;
13604  byte enabled = 1;
13605  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, selected, enabled);
13606  if (labelByteCount > Util.StackAllocationSizeLimit)
13607  {
13608  Util.Free(nativeLabel);
13609  }
13610 
13611  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13612  {
13613  Util.Free(nativeShortcut);
13614  }
13615 
13616  return ret != 0;
13617  }
13618 
13626  public static bool MenuItem(string label, string shortcut, bool selected)
13627  {
13628  byte* nativeLabel;
13629  int labelByteCount = 0;
13630  if (label != null)
13631  {
13632  labelByteCount = Encoding.UTF8.GetByteCount(label);
13633  if (labelByteCount > Util.StackAllocationSizeLimit)
13634  {
13635  nativeLabel = Util.Allocate(labelByteCount + 1);
13636  }
13637  else
13638  {
13639  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13640  nativeLabel = nativeLabelStackBytes;
13641  }
13642 
13643  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13644  nativeLabel[nativeLabelOffset] = 0;
13645  }
13646  else
13647  {
13648  nativeLabel = null;
13649  }
13650 
13651  byte* nativeShortcut;
13652  int shortcutByteCount = 0;
13653  if (shortcut != null)
13654  {
13655  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13656  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13657  {
13658  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13659  }
13660  else
13661  {
13662  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13663  nativeShortcut = nativeShortcutStackBytes;
13664  }
13665 
13666  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13667  nativeShortcut[nativeShortcutOffset] = 0;
13668  }
13669  else
13670  {
13671  nativeShortcut = null;
13672  }
13673 
13674  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
13675  byte enabled = 1;
13676  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, nativeSelected, enabled);
13677  if (labelByteCount > Util.StackAllocationSizeLimit)
13678  {
13679  Util.Free(nativeLabel);
13680  }
13681 
13682  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13683  {
13684  Util.Free(nativeShortcut);
13685  }
13686 
13687  return ret != 0;
13688  }
13689 
13698  public static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
13699  {
13700  byte* nativeLabel;
13701  int labelByteCount = 0;
13702  if (label != null)
13703  {
13704  labelByteCount = Encoding.UTF8.GetByteCount(label);
13705  if (labelByteCount > Util.StackAllocationSizeLimit)
13706  {
13707  nativeLabel = Util.Allocate(labelByteCount + 1);
13708  }
13709  else
13710  {
13711  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13712  nativeLabel = nativeLabelStackBytes;
13713  }
13714 
13715  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13716  nativeLabel[nativeLabelOffset] = 0;
13717  }
13718  else
13719  {
13720  nativeLabel = null;
13721  }
13722 
13723  byte* nativeShortcut;
13724  int shortcutByteCount = 0;
13725  if (shortcut != null)
13726  {
13727  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13728  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13729  {
13730  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13731  }
13732  else
13733  {
13734  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13735  nativeShortcut = nativeShortcutStackBytes;
13736  }
13737 
13738  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13739  nativeShortcut[nativeShortcutOffset] = 0;
13740  }
13741  else
13742  {
13743  nativeShortcut = null;
13744  }
13745 
13746  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
13747  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
13748  byte ret = ImGuiNative.igMenuItem_Bool(nativeLabel, nativeShortcut, nativeSelected, nativeEnabled);
13749  if (labelByteCount > Util.StackAllocationSizeLimit)
13750  {
13751  Util.Free(nativeLabel);
13752  }
13753 
13754  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13755  {
13756  Util.Free(nativeShortcut);
13757  }
13758 
13759  return ret != 0;
13760  }
13761 
13769  public static bool MenuItem(string label, string shortcut, ref bool pSelected)
13770  {
13771  byte* nativeLabel;
13772  int labelByteCount = 0;
13773  if (label != null)
13774  {
13775  labelByteCount = Encoding.UTF8.GetByteCount(label);
13776  if (labelByteCount > Util.StackAllocationSizeLimit)
13777  {
13778  nativeLabel = Util.Allocate(labelByteCount + 1);
13779  }
13780  else
13781  {
13782  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13783  nativeLabel = nativeLabelStackBytes;
13784  }
13785 
13786  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13787  nativeLabel[nativeLabelOffset] = 0;
13788  }
13789  else
13790  {
13791  nativeLabel = null;
13792  }
13793 
13794  byte* nativeShortcut;
13795  int shortcutByteCount = 0;
13796  if (shortcut != null)
13797  {
13798  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13799  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13800  {
13801  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13802  }
13803  else
13804  {
13805  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13806  nativeShortcut = nativeShortcutStackBytes;
13807  }
13808 
13809  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13810  nativeShortcut[nativeShortcutOffset] = 0;
13811  }
13812  else
13813  {
13814  nativeShortcut = null;
13815  }
13816 
13817  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
13818  byte* nativePSelected = &nativePSelectedVal;
13819  byte enabled = 1;
13820  byte ret = ImGuiNative.igMenuItem_BoolPtr(nativeLabel, nativeShortcut, nativePSelected, enabled);
13821  if (labelByteCount > Util.StackAllocationSizeLimit)
13822  {
13823  Util.Free(nativeLabel);
13824  }
13825 
13826  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13827  {
13828  Util.Free(nativeShortcut);
13829  }
13830 
13831  pSelected = nativePSelectedVal != 0;
13832  return ret != 0;
13833  }
13834 
13843  public static bool MenuItem(string label, string shortcut, ref bool pSelected, bool enabled)
13844  {
13845  byte* nativeLabel;
13846  int labelByteCount = 0;
13847  if (label != null)
13848  {
13849  labelByteCount = Encoding.UTF8.GetByteCount(label);
13850  if (labelByteCount > Util.StackAllocationSizeLimit)
13851  {
13852  nativeLabel = Util.Allocate(labelByteCount + 1);
13853  }
13854  else
13855  {
13856  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
13857  nativeLabel = nativeLabelStackBytes;
13858  }
13859 
13860  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
13861  nativeLabel[nativeLabelOffset] = 0;
13862  }
13863  else
13864  {
13865  nativeLabel = null;
13866  }
13867 
13868  byte* nativeShortcut;
13869  int shortcutByteCount = 0;
13870  if (shortcut != null)
13871  {
13872  shortcutByteCount = Encoding.UTF8.GetByteCount(shortcut);
13873  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13874  {
13875  nativeShortcut = Util.Allocate(shortcutByteCount + 1);
13876  }
13877  else
13878  {
13879  byte* nativeShortcutStackBytes = stackalloc byte[shortcutByteCount + 1];
13880  nativeShortcut = nativeShortcutStackBytes;
13881  }
13882 
13883  int nativeShortcutOffset = Util.GetUtf8(shortcut, nativeShortcut, shortcutByteCount);
13884  nativeShortcut[nativeShortcutOffset] = 0;
13885  }
13886  else
13887  {
13888  nativeShortcut = null;
13889  }
13890 
13891  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
13892  byte* nativePSelected = &nativePSelectedVal;
13893  byte nativeEnabled = enabled ? (byte) 1 : (byte) 0;
13894  byte ret = ImGuiNative.igMenuItem_BoolPtr(nativeLabel, nativeShortcut, nativePSelected, nativeEnabled);
13895  if (labelByteCount > Util.StackAllocationSizeLimit)
13896  {
13897  Util.Free(nativeLabel);
13898  }
13899 
13900  if (shortcutByteCount > Util.StackAllocationSizeLimit)
13901  {
13902  Util.Free(nativeShortcut);
13903  }
13904 
13905  pSelected = nativePSelectedVal != 0;
13906  return ret != 0;
13907  }
13908 
13912  public static void NewFrame()
13913  {
13915  }
13916 
13920  public static void NewLine()
13921  {
13923  }
13924 
13928  public static void NextColumn()
13929  {
13931  }
13932 
13937  public static void OpenPopup(string strId)
13938  {
13939  byte* nativeStrId;
13940  int strIdByteCount = 0;
13941  if (strId != null)
13942  {
13943  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13944  if (strIdByteCount > Util.StackAllocationSizeLimit)
13945  {
13946  nativeStrId = Util.Allocate(strIdByteCount + 1);
13947  }
13948  else
13949  {
13950  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
13951  nativeStrId = nativeStrIdStackBytes;
13952  }
13953 
13954  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
13955  nativeStrId[nativeStrIdOffset] = 0;
13956  }
13957  else
13958  {
13959  nativeStrId = null;
13960  }
13961 
13962  ImGuiPopups popups = 0;
13963  ImGuiNative.igOpenPopup_Str(nativeStrId, popups);
13964  if (strIdByteCount > Util.StackAllocationSizeLimit)
13965  {
13966  Util.Free(nativeStrId);
13967  }
13968  }
13969 
13975  public static void OpenPopup(string strId, ImGuiPopups popups)
13976  {
13977  byte* nativeStrId;
13978  int strIdByteCount = 0;
13979  if (strId != null)
13980  {
13981  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
13982  if (strIdByteCount > Util.StackAllocationSizeLimit)
13983  {
13984  nativeStrId = Util.Allocate(strIdByteCount + 1);
13985  }
13986  else
13987  {
13988  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
13989  nativeStrId = nativeStrIdStackBytes;
13990  }
13991 
13992  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
13993  nativeStrId[nativeStrIdOffset] = 0;
13994  }
13995  else
13996  {
13997  nativeStrId = null;
13998  }
13999 
14000  ImGuiNative.igOpenPopup_Str(nativeStrId, popups);
14001  if (strIdByteCount > Util.StackAllocationSizeLimit)
14002  {
14003  Util.Free(nativeStrId);
14004  }
14005  }
14006 
14011  public static void OpenPopup(uint id)
14012  {
14013  ImGuiPopups popups = 0;
14014  ImGuiNative.igOpenPopup_ID(id, popups);
14015  }
14016 
14022  public static void OpenPopup(uint id, ImGuiPopups popups)
14023  {
14024  ImGuiNative.igOpenPopup_ID(id, popups);
14025  }
14026 
14030  public static void OpenPopupOnItemClick()
14031  {
14032  byte* nativeStrId = null;
14033  ImGuiPopups popups = (ImGuiPopups) 1;
14034  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popups);
14035  }
14036 
14041  public static void OpenPopupOnItemClick(string strId)
14042  {
14043  byte* nativeStrId;
14044  int strIdByteCount = 0;
14045  if (strId != null)
14046  {
14047  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14048  if (strIdByteCount > Util.StackAllocationSizeLimit)
14049  {
14050  nativeStrId = Util.Allocate(strIdByteCount + 1);
14051  }
14052  else
14053  {
14054  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
14055  nativeStrId = nativeStrIdStackBytes;
14056  }
14057 
14058  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
14059  nativeStrId[nativeStrIdOffset] = 0;
14060  }
14061  else
14062  {
14063  nativeStrId = null;
14064  }
14065 
14066  ImGuiPopups popups = (ImGuiPopups) 1;
14067  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popups);
14068  if (strIdByteCount > Util.StackAllocationSizeLimit)
14069  {
14070  Util.Free(nativeStrId);
14071  }
14072  }
14073 
14079  public static void OpenPopupOnItemClick(string strId, ImGuiPopups popups)
14080  {
14081  byte* nativeStrId;
14082  int strIdByteCount = 0;
14083  if (strId != null)
14084  {
14085  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
14086  if (strIdByteCount > Util.StackAllocationSizeLimit)
14087  {
14088  nativeStrId = Util.Allocate(strIdByteCount + 1);
14089  }
14090  else
14091  {
14092  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
14093  nativeStrId = nativeStrIdStackBytes;
14094  }
14095 
14096  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
14097  nativeStrId[nativeStrIdOffset] = 0;
14098  }
14099  else
14100  {
14101  nativeStrId = null;
14102  }
14103 
14104  ImGuiNative.igOpenPopupOnItemClick(nativeStrId, popups);
14105  if (strIdByteCount > Util.StackAllocationSizeLimit)
14106  {
14107  Util.Free(nativeStrId);
14108  }
14109  }
14110 
14117  public static void PlotHistogram(string label, ref float values, int valuesCount)
14118  {
14119  byte* nativeLabel;
14120  int labelByteCount = 0;
14121  if (label != null)
14122  {
14123  labelByteCount = Encoding.UTF8.GetByteCount(label);
14124  if (labelByteCount > Util.StackAllocationSizeLimit)
14125  {
14126  nativeLabel = Util.Allocate(labelByteCount + 1);
14127  }
14128  else
14129  {
14130  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14131  nativeLabel = nativeLabelStackBytes;
14132  }
14133 
14134  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14135  nativeLabel[nativeLabelOffset] = 0;
14136  }
14137  else
14138  {
14139  nativeLabel = null;
14140  }
14141 
14142  int valuesOffset = 0;
14143  byte* nativeOverlayText = null;
14144  float scaleMin = float.MaxValue;
14145  float scaleMax = float.MaxValue;
14146  Vector2F graphSize = new Vector2F();
14147  int stride = sizeof(float);
14148  fixed (float* nativeValues = &values)
14149  {
14150  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14151  if (labelByteCount > Util.StackAllocationSizeLimit)
14152  {
14153  Util.Free(nativeLabel);
14154  }
14155  }
14156  }
14157 
14165  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset)
14166  {
14167  byte* nativeLabel;
14168  int labelByteCount = 0;
14169  if (label != null)
14170  {
14171  labelByteCount = Encoding.UTF8.GetByteCount(label);
14172  if (labelByteCount > Util.StackAllocationSizeLimit)
14173  {
14174  nativeLabel = Util.Allocate(labelByteCount + 1);
14175  }
14176  else
14177  {
14178  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14179  nativeLabel = nativeLabelStackBytes;
14180  }
14181 
14182  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14183  nativeLabel[nativeLabelOffset] = 0;
14184  }
14185  else
14186  {
14187  nativeLabel = null;
14188  }
14189 
14190  byte* nativeOverlayText = null;
14191  float scaleMin = float.MaxValue;
14192  float scaleMax = float.MaxValue;
14193  Vector2F graphSize = new Vector2F();
14194  int stride = sizeof(float);
14195  fixed (float* nativeValues = &values)
14196  {
14197  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14198  if (labelByteCount > Util.StackAllocationSizeLimit)
14199  {
14200  Util.Free(nativeLabel);
14201  }
14202  }
14203  }
14204 
14213  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
14214  {
14215  byte* nativeLabel;
14216  int labelByteCount = 0;
14217  if (label != null)
14218  {
14219  labelByteCount = Encoding.UTF8.GetByteCount(label);
14220  if (labelByteCount > Util.StackAllocationSizeLimit)
14221  {
14222  nativeLabel = Util.Allocate(labelByteCount + 1);
14223  }
14224  else
14225  {
14226  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14227  nativeLabel = nativeLabelStackBytes;
14228  }
14229 
14230  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14231  nativeLabel[nativeLabelOffset] = 0;
14232  }
14233  else
14234  {
14235  nativeLabel = null;
14236  }
14237 
14238  byte* nativeOverlayText;
14239  int overlayTextByteCount = 0;
14240  if (overlayText != null)
14241  {
14242  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14243  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14244  {
14245  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14246  }
14247  else
14248  {
14249  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14250  nativeOverlayText = nativeOverlayTextStackBytes;
14251  }
14252 
14253  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14254  nativeOverlayText[nativeOverlayTextOffset] = 0;
14255  }
14256  else
14257  {
14258  nativeOverlayText = null;
14259  }
14260 
14261  float scaleMin = float.MaxValue;
14262  float scaleMax = float.MaxValue;
14263  Vector2F graphSize = new Vector2F();
14264  int stride = sizeof(float);
14265  fixed (float* nativeValues = &values)
14266  {
14267  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14268  if (labelByteCount > Util.StackAllocationSizeLimit)
14269  {
14270  Util.Free(nativeLabel);
14271  }
14272 
14273  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14274  {
14275  Util.Free(nativeOverlayText);
14276  }
14277  }
14278  }
14279 
14289  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
14290  {
14291  byte* nativeLabel;
14292  int labelByteCount = 0;
14293  if (label != null)
14294  {
14295  labelByteCount = Encoding.UTF8.GetByteCount(label);
14296  if (labelByteCount > Util.StackAllocationSizeLimit)
14297  {
14298  nativeLabel = Util.Allocate(labelByteCount + 1);
14299  }
14300  else
14301  {
14302  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14303  nativeLabel = nativeLabelStackBytes;
14304  }
14305 
14306  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14307  nativeLabel[nativeLabelOffset] = 0;
14308  }
14309  else
14310  {
14311  nativeLabel = null;
14312  }
14313 
14314  byte* nativeOverlayText;
14315  int overlayTextByteCount = 0;
14316  if (overlayText != null)
14317  {
14318  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14319  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14320  {
14321  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14322  }
14323  else
14324  {
14325  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14326  nativeOverlayText = nativeOverlayTextStackBytes;
14327  }
14328 
14329  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14330  nativeOverlayText[nativeOverlayTextOffset] = 0;
14331  }
14332  else
14333  {
14334  nativeOverlayText = null;
14335  }
14336 
14337  float scaleMax = float.MaxValue;
14338  Vector2F graphSize = new Vector2F();
14339  int stride = sizeof(float);
14340  fixed (float* nativeValues = &values)
14341  {
14342  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14343  if (labelByteCount > Util.StackAllocationSizeLimit)
14344  {
14345  Util.Free(nativeLabel);
14346  }
14347 
14348  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14349  {
14350  Util.Free(nativeOverlayText);
14351  }
14352  }
14353  }
14354 
14365  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
14366  {
14367  byte* nativeLabel;
14368  int labelByteCount = 0;
14369  if (label != null)
14370  {
14371  labelByteCount = Encoding.UTF8.GetByteCount(label);
14372  if (labelByteCount > Util.StackAllocationSizeLimit)
14373  {
14374  nativeLabel = Util.Allocate(labelByteCount + 1);
14375  }
14376  else
14377  {
14378  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14379  nativeLabel = nativeLabelStackBytes;
14380  }
14381 
14382  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14383  nativeLabel[nativeLabelOffset] = 0;
14384  }
14385  else
14386  {
14387  nativeLabel = null;
14388  }
14389 
14390  byte* nativeOverlayText;
14391  int overlayTextByteCount = 0;
14392  if (overlayText != null)
14393  {
14394  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14395  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14396  {
14397  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14398  }
14399  else
14400  {
14401  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14402  nativeOverlayText = nativeOverlayTextStackBytes;
14403  }
14404 
14405  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14406  nativeOverlayText[nativeOverlayTextOffset] = 0;
14407  }
14408  else
14409  {
14410  nativeOverlayText = null;
14411  }
14412 
14413  Vector2F graphSize = new Vector2F();
14414  int stride = sizeof(float);
14415  fixed (float* nativeValues = &values)
14416  {
14417  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14418  if (labelByteCount > Util.StackAllocationSizeLimit)
14419  {
14420  Util.Free(nativeLabel);
14421  }
14422 
14423  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14424  {
14425  Util.Free(nativeOverlayText);
14426  }
14427  }
14428  }
14429 
14441  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
14442  {
14443  byte* nativeLabel;
14444  int labelByteCount = 0;
14445  if (label != null)
14446  {
14447  labelByteCount = Encoding.UTF8.GetByteCount(label);
14448  if (labelByteCount > Util.StackAllocationSizeLimit)
14449  {
14450  nativeLabel = Util.Allocate(labelByteCount + 1);
14451  }
14452  else
14453  {
14454  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14455  nativeLabel = nativeLabelStackBytes;
14456  }
14457 
14458  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14459  nativeLabel[nativeLabelOffset] = 0;
14460  }
14461  else
14462  {
14463  nativeLabel = null;
14464  }
14465 
14466  byte* nativeOverlayText;
14467  int overlayTextByteCount = 0;
14468  if (overlayText != null)
14469  {
14470  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14471  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14472  {
14473  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14474  }
14475  else
14476  {
14477  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14478  nativeOverlayText = nativeOverlayTextStackBytes;
14479  }
14480 
14481  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14482  nativeOverlayText[nativeOverlayTextOffset] = 0;
14483  }
14484  else
14485  {
14486  nativeOverlayText = null;
14487  }
14488 
14489  int stride = sizeof(float);
14490  fixed (float* nativeValues = &values)
14491  {
14492  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14493  if (labelByteCount > Util.StackAllocationSizeLimit)
14494  {
14495  Util.Free(nativeLabel);
14496  }
14497 
14498  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14499  {
14500  Util.Free(nativeOverlayText);
14501  }
14502  }
14503  }
14504 
14517  public static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
14518  {
14519  byte* nativeLabel;
14520  int labelByteCount = 0;
14521  if (label != null)
14522  {
14523  labelByteCount = Encoding.UTF8.GetByteCount(label);
14524  if (labelByteCount > Util.StackAllocationSizeLimit)
14525  {
14526  nativeLabel = Util.Allocate(labelByteCount + 1);
14527  }
14528  else
14529  {
14530  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14531  nativeLabel = nativeLabelStackBytes;
14532  }
14533 
14534  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14535  nativeLabel[nativeLabelOffset] = 0;
14536  }
14537  else
14538  {
14539  nativeLabel = null;
14540  }
14541 
14542  byte* nativeOverlayText;
14543  int overlayTextByteCount = 0;
14544  if (overlayText != null)
14545  {
14546  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14547  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14548  {
14549  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14550  }
14551  else
14552  {
14553  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14554  nativeOverlayText = nativeOverlayTextStackBytes;
14555  }
14556 
14557  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14558  nativeOverlayText[nativeOverlayTextOffset] = 0;
14559  }
14560  else
14561  {
14562  nativeOverlayText = null;
14563  }
14564 
14565  fixed (float* nativeValues = &values)
14566  {
14567  ImGuiNative.igPlotHistogram_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14568  if (labelByteCount > Util.StackAllocationSizeLimit)
14569  {
14570  Util.Free(nativeLabel);
14571  }
14572 
14573  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14574  {
14575  Util.Free(nativeOverlayText);
14576  }
14577  }
14578  }
14579 
14586  public static void PlotLines(string label, ref float values, int valuesCount)
14587  {
14588  byte* nativeLabel;
14589  int labelByteCount = 0;
14590  if (label != null)
14591  {
14592  labelByteCount = Encoding.UTF8.GetByteCount(label);
14593  if (labelByteCount > Util.StackAllocationSizeLimit)
14594  {
14595  nativeLabel = Util.Allocate(labelByteCount + 1);
14596  }
14597  else
14598  {
14599  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14600  nativeLabel = nativeLabelStackBytes;
14601  }
14602 
14603  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14604  nativeLabel[nativeLabelOffset] = 0;
14605  }
14606  else
14607  {
14608  nativeLabel = null;
14609  }
14610 
14611  int valuesOffset = 0;
14612  byte* nativeOverlayText = null;
14613  float scaleMin = float.MaxValue;
14614  float scaleMax = float.MaxValue;
14615  Vector2F graphSize = new Vector2F();
14616  int stride = sizeof(float);
14617  fixed (float* nativeValues = &values)
14618  {
14619  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14620  if (labelByteCount > Util.StackAllocationSizeLimit)
14621  {
14622  Util.Free(nativeLabel);
14623  }
14624  }
14625  }
14626 
14634  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset)
14635  {
14636  byte* nativeLabel;
14637  int labelByteCount = 0;
14638  if (label != null)
14639  {
14640  labelByteCount = Encoding.UTF8.GetByteCount(label);
14641  if (labelByteCount > Util.StackAllocationSizeLimit)
14642  {
14643  nativeLabel = Util.Allocate(labelByteCount + 1);
14644  }
14645  else
14646  {
14647  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14648  nativeLabel = nativeLabelStackBytes;
14649  }
14650 
14651  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14652  nativeLabel[nativeLabelOffset] = 0;
14653  }
14654  else
14655  {
14656  nativeLabel = null;
14657  }
14658 
14659  byte* nativeOverlayText = null;
14660  float scaleMin = float.MaxValue;
14661  float scaleMax = float.MaxValue;
14662  Vector2F graphSize = new Vector2F();
14663  int stride = sizeof(float);
14664  fixed (float* nativeValues = &values)
14665  {
14666  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14667  if (labelByteCount > Util.StackAllocationSizeLimit)
14668  {
14669  Util.Free(nativeLabel);
14670  }
14671  }
14672  }
14673 
14682  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
14683  {
14684  byte* nativeLabel;
14685  int labelByteCount = 0;
14686  if (label != null)
14687  {
14688  labelByteCount = Encoding.UTF8.GetByteCount(label);
14689  if (labelByteCount > Util.StackAllocationSizeLimit)
14690  {
14691  nativeLabel = Util.Allocate(labelByteCount + 1);
14692  }
14693  else
14694  {
14695  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14696  nativeLabel = nativeLabelStackBytes;
14697  }
14698 
14699  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14700  nativeLabel[nativeLabelOffset] = 0;
14701  }
14702  else
14703  {
14704  nativeLabel = null;
14705  }
14706 
14707  byte* nativeOverlayText;
14708  int overlayTextByteCount = 0;
14709  if (overlayText != null)
14710  {
14711  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14712  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14713  {
14714  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14715  }
14716  else
14717  {
14718  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14719  nativeOverlayText = nativeOverlayTextStackBytes;
14720  }
14721 
14722  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14723  nativeOverlayText[nativeOverlayTextOffset] = 0;
14724  }
14725  else
14726  {
14727  nativeOverlayText = null;
14728  }
14729 
14730  float scaleMin = float.MaxValue;
14731  float scaleMax = float.MaxValue;
14732  Vector2F graphSize = new Vector2F();
14733  int stride = sizeof(float);
14734  fixed (float* nativeValues = &values)
14735  {
14736  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14737  if (labelByteCount > Util.StackAllocationSizeLimit)
14738  {
14739  Util.Free(nativeLabel);
14740  }
14741 
14742  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14743  {
14744  Util.Free(nativeOverlayText);
14745  }
14746  }
14747  }
14748 
14758  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
14759  {
14760  byte* nativeLabel;
14761  int labelByteCount = 0;
14762  if (label != null)
14763  {
14764  labelByteCount = Encoding.UTF8.GetByteCount(label);
14765  if (labelByteCount > Util.StackAllocationSizeLimit)
14766  {
14767  nativeLabel = Util.Allocate(labelByteCount + 1);
14768  }
14769  else
14770  {
14771  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14772  nativeLabel = nativeLabelStackBytes;
14773  }
14774 
14775  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14776  nativeLabel[nativeLabelOffset] = 0;
14777  }
14778  else
14779  {
14780  nativeLabel = null;
14781  }
14782 
14783  byte* nativeOverlayText;
14784  int overlayTextByteCount = 0;
14785  if (overlayText != null)
14786  {
14787  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14788  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14789  {
14790  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14791  }
14792  else
14793  {
14794  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14795  nativeOverlayText = nativeOverlayTextStackBytes;
14796  }
14797 
14798  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14799  nativeOverlayText[nativeOverlayTextOffset] = 0;
14800  }
14801  else
14802  {
14803  nativeOverlayText = null;
14804  }
14805 
14806  float scaleMax = float.MaxValue;
14807  Vector2F graphSize = new Vector2F();
14808  int stride = sizeof(float);
14809  fixed (float* nativeValues = &values)
14810  {
14811  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14812  if (labelByteCount > Util.StackAllocationSizeLimit)
14813  {
14814  Util.Free(nativeLabel);
14815  }
14816 
14817  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14818  {
14819  Util.Free(nativeOverlayText);
14820  }
14821  }
14822  }
14823 
14834  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
14835  {
14836  byte* nativeLabel;
14837  int labelByteCount = 0;
14838  if (label != null)
14839  {
14840  labelByteCount = Encoding.UTF8.GetByteCount(label);
14841  if (labelByteCount > Util.StackAllocationSizeLimit)
14842  {
14843  nativeLabel = Util.Allocate(labelByteCount + 1);
14844  }
14845  else
14846  {
14847  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14848  nativeLabel = nativeLabelStackBytes;
14849  }
14850 
14851  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14852  nativeLabel[nativeLabelOffset] = 0;
14853  }
14854  else
14855  {
14856  nativeLabel = null;
14857  }
14858 
14859  byte* nativeOverlayText;
14860  int overlayTextByteCount = 0;
14861  if (overlayText != null)
14862  {
14863  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14864  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14865  {
14866  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14867  }
14868  else
14869  {
14870  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14871  nativeOverlayText = nativeOverlayTextStackBytes;
14872  }
14873 
14874  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14875  nativeOverlayText[nativeOverlayTextOffset] = 0;
14876  }
14877  else
14878  {
14879  nativeOverlayText = null;
14880  }
14881 
14882  Vector2F graphSize = new Vector2F();
14883  int stride = sizeof(float);
14884  fixed (float* nativeValues = &values)
14885  {
14886  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14887  if (labelByteCount > Util.StackAllocationSizeLimit)
14888  {
14889  Util.Free(nativeLabel);
14890  }
14891 
14892  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14893  {
14894  Util.Free(nativeOverlayText);
14895  }
14896  }
14897  }
14898 
14910  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
14911  {
14912  byte* nativeLabel;
14913  int labelByteCount = 0;
14914  if (label != null)
14915  {
14916  labelByteCount = Encoding.UTF8.GetByteCount(label);
14917  if (labelByteCount > Util.StackAllocationSizeLimit)
14918  {
14919  nativeLabel = Util.Allocate(labelByteCount + 1);
14920  }
14921  else
14922  {
14923  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
14924  nativeLabel = nativeLabelStackBytes;
14925  }
14926 
14927  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
14928  nativeLabel[nativeLabelOffset] = 0;
14929  }
14930  else
14931  {
14932  nativeLabel = null;
14933  }
14934 
14935  byte* nativeOverlayText;
14936  int overlayTextByteCount = 0;
14937  if (overlayText != null)
14938  {
14939  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
14940  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14941  {
14942  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
14943  }
14944  else
14945  {
14946  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
14947  nativeOverlayText = nativeOverlayTextStackBytes;
14948  }
14949 
14950  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
14951  nativeOverlayText[nativeOverlayTextOffset] = 0;
14952  }
14953  else
14954  {
14955  nativeOverlayText = null;
14956  }
14957 
14958  int stride = sizeof(float);
14959  fixed (float* nativeValues = &values)
14960  {
14961  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
14962  if (labelByteCount > Util.StackAllocationSizeLimit)
14963  {
14964  Util.Free(nativeLabel);
14965  }
14966 
14967  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
14968  {
14969  Util.Free(nativeOverlayText);
14970  }
14971  }
14972  }
14973 
14986  public static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
14987  {
14988  byte* nativeLabel;
14989  int labelByteCount = 0;
14990  if (label != null)
14991  {
14992  labelByteCount = Encoding.UTF8.GetByteCount(label);
14993  if (labelByteCount > Util.StackAllocationSizeLimit)
14994  {
14995  nativeLabel = Util.Allocate(labelByteCount + 1);
14996  }
14997  else
14998  {
14999  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15000  nativeLabel = nativeLabelStackBytes;
15001  }
15002 
15003  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15004  nativeLabel[nativeLabelOffset] = 0;
15005  }
15006  else
15007  {
15008  nativeLabel = null;
15009  }
15010 
15011  byte* nativeOverlayText;
15012  int overlayTextByteCount = 0;
15013  if (overlayText != null)
15014  {
15015  overlayTextByteCount = Encoding.UTF8.GetByteCount(overlayText);
15016  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
15017  {
15018  nativeOverlayText = Util.Allocate(overlayTextByteCount + 1);
15019  }
15020  else
15021  {
15022  byte* nativeOverlayTextStackBytes = stackalloc byte[overlayTextByteCount + 1];
15023  nativeOverlayText = nativeOverlayTextStackBytes;
15024  }
15025 
15026  int nativeOverlayTextOffset = Util.GetUtf8(overlayText, nativeOverlayText, overlayTextByteCount);
15027  nativeOverlayText[nativeOverlayTextOffset] = 0;
15028  }
15029  else
15030  {
15031  nativeOverlayText = null;
15032  }
15033 
15034  fixed (float* nativeValues = &values)
15035  {
15036  ImGuiNative.igPlotLines_FloatPtr(nativeLabel, nativeValues, valuesCount, valuesOffset, nativeOverlayText, scaleMin, scaleMax, graphSize, stride);
15037  if (labelByteCount > Util.StackAllocationSizeLimit)
15038  {
15039  Util.Free(nativeLabel);
15040  }
15041 
15042  if (overlayTextByteCount > Util.StackAllocationSizeLimit)
15043  {
15044  Util.Free(nativeOverlayText);
15045  }
15046  }
15047  }
15048 
15052  public static void PopButtonRepeat()
15053  {
15055  }
15056 
15060  public static void PopClipRect()
15061  {
15063  }
15064 
15068  public static void PopFont()
15069  {
15071  }
15072 
15076  public static void PopId()
15077  {
15078  ImGuiNative.igPopID();
15079  }
15080 
15084  public static void PopItemWidth()
15085  {
15087  }
15088 
15092  public static void PopStyleColor()
15093  {
15094  int count = 1;
15096  }
15097 
15102  public static void PopStyleColor(int count)
15103  {
15105  }
15106 
15110  public static void PopStyleVar()
15111  {
15112  int count = 1;
15113  ImGuiNative.igPopStyleVar(count);
15114  }
15115 
15120  public static void PopStyleVar(int count)
15121  {
15122  ImGuiNative.igPopStyleVar(count);
15123  }
15124 
15128  public static void PopTabStop()
15129  {
15131  }
15132 
15136  public static void PopTextWrapPos()
15137  {
15139  }
15140 
15145  public static void ProgressBar(float fraction)
15146  {
15147  Vector2F sizeArg = new Vector2F(-float.MinValue, 0.0f);
15148  byte* nativeOverlay = null;
15149  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15150  }
15151 
15157  public static void ProgressBar(float fraction, Vector2F sizeArg)
15158  {
15159  byte* nativeOverlay = null;
15160  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15161  }
15162 
15169  public static void ProgressBar(float fraction, Vector2F sizeArg, string overlay)
15170  {
15171  byte* nativeOverlay;
15172  int overlayByteCount = 0;
15173  if (overlay != null)
15174  {
15175  overlayByteCount = Encoding.UTF8.GetByteCount(overlay);
15176  if (overlayByteCount > Util.StackAllocationSizeLimit)
15177  {
15178  nativeOverlay = Util.Allocate(overlayByteCount + 1);
15179  }
15180  else
15181  {
15182  byte* nativeOverlayStackBytes = stackalloc byte[overlayByteCount + 1];
15183  nativeOverlay = nativeOverlayStackBytes;
15184  }
15185 
15186  int nativeOverlayOffset = Util.GetUtf8(overlay, nativeOverlay, overlayByteCount);
15187  nativeOverlay[nativeOverlayOffset] = 0;
15188  }
15189  else
15190  {
15191  nativeOverlay = null;
15192  }
15193 
15194  ImGuiNative.igProgressBar(fraction, sizeArg, nativeOverlay);
15195  if (overlayByteCount > Util.StackAllocationSizeLimit)
15196  {
15197  Util.Free(nativeOverlay);
15198  }
15199  }
15200 
15205  public static void PushButtonRepeat(bool repeat)
15206  {
15207  byte nativeRepeat = repeat ? (byte) 1 : (byte) 0;
15208  ImGuiNative.igPushButtonRepeat(nativeRepeat);
15209  }
15210 
15217  public static void PushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, bool intersectWithCurrentClipRect)
15218  {
15219  byte nativeIntersectWithCurrentClipRect = intersectWithCurrentClipRect ? (byte) 1 : (byte) 0;
15220  ImGuiNative.igPushClipRect(clipRectMin, clipRectMax, nativeIntersectWithCurrentClipRect);
15221  }
15222 
15227  public static void PushFont(ImFontPtr font)
15228  {
15229  ImFont* nativeFont = font.NativePtr;
15230  ImGuiNative.igPushFont(nativeFont);
15231  }
15232 
15237  public static void PushId(string strId)
15238  {
15239  byte* nativeStrId;
15240  int strIdByteCount = 0;
15241  if (strId != null)
15242  {
15243  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
15244  if (strIdByteCount > Util.StackAllocationSizeLimit)
15245  {
15246  nativeStrId = Util.Allocate(strIdByteCount + 1);
15247  }
15248  else
15249  {
15250  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
15251  nativeStrId = nativeStrIdStackBytes;
15252  }
15253 
15254  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
15255  nativeStrId[nativeStrIdOffset] = 0;
15256  }
15257  else
15258  {
15259  nativeStrId = null;
15260  }
15261 
15262  ImGuiNative.igPushID_Str(nativeStrId);
15263  if (strIdByteCount > Util.StackAllocationSizeLimit)
15264  {
15265  Util.Free(nativeStrId);
15266  }
15267  }
15268 
15273  public static void PushId(IntPtr ptrId)
15274  {
15275  void* nativePtrId = ptrId.ToPointer();
15276  ImGuiNative.igPushID_Ptr(nativePtrId);
15277  }
15278 
15283  public static void PushId(int intId)
15284  {
15285  ImGuiNative.igPushID_Int(intId);
15286  }
15287 
15292  public static void PushItemWidth(float itemWidth)
15293  {
15294  ImGuiNative.igPushItemWidth(itemWidth);
15295  }
15296 
15302  public static void PushStyleColor(ImGuiCol idx, uint col)
15303  {
15305  }
15306 
15312  public static void PushStyleColor(ImGuiCol idx, Vector4F col)
15313  {
15315  }
15316 
15322  public static void PushStyleVar(ImGuiStyleVar idx, float val)
15323  {
15325  }
15326 
15332  public static void PushStyleVar(ImGuiStyleVar idx, Vector2F val)
15333  {
15334  ImGuiNative.igPushStyleVar_Vec2(idx, val);
15335  }
15336 
15341  public static void PushTabStop(bool tabStop)
15342  {
15343  byte nativeTabStop = tabStop ? (byte) 1 : (byte) 0;
15344  ImGuiNative.igPushTabStop(nativeTabStop);
15345  }
15346 
15350  public static void PushTextWrapPos()
15351  {
15352  float wrapLocalPosX = 0.0f;
15353  ImGuiNative.igPushTextWrapPos(wrapLocalPosX);
15354  }
15355 
15360  public static void PushTextWrapPos(float wrapLocalPosX)
15361  {
15362  ImGuiNative.igPushTextWrapPos(wrapLocalPosX);
15363  }
15364 
15371  public static bool RadioButton(string label, bool active)
15372  {
15373  byte* nativeLabel;
15374  int labelByteCount = 0;
15375  if (label != null)
15376  {
15377  labelByteCount = Encoding.UTF8.GetByteCount(label);
15378  if (labelByteCount > Util.StackAllocationSizeLimit)
15379  {
15380  nativeLabel = Util.Allocate(labelByteCount + 1);
15381  }
15382  else
15383  {
15384  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15385  nativeLabel = nativeLabelStackBytes;
15386  }
15387 
15388  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15389  nativeLabel[nativeLabelOffset] = 0;
15390  }
15391  else
15392  {
15393  nativeLabel = null;
15394  }
15395 
15396  byte nativeActive = active ? (byte) 1 : (byte) 0;
15397  byte ret = ImGuiNative.igRadioButton_Bool(nativeLabel, nativeActive);
15398  if (labelByteCount > Util.StackAllocationSizeLimit)
15399  {
15400  Util.Free(nativeLabel);
15401  }
15402 
15403  return ret != 0;
15404  }
15405 
15413  public static bool RadioButton(string label, ref int v, int vButton)
15414  {
15415  byte* nativeLabel;
15416  int labelByteCount = 0;
15417  if (label != null)
15418  {
15419  labelByteCount = Encoding.UTF8.GetByteCount(label);
15420  if (labelByteCount > Util.StackAllocationSizeLimit)
15421  {
15422  nativeLabel = Util.Allocate(labelByteCount + 1);
15423  }
15424  else
15425  {
15426  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15427  nativeLabel = nativeLabelStackBytes;
15428  }
15429 
15430  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15431  nativeLabel[nativeLabelOffset] = 0;
15432  }
15433  else
15434  {
15435  nativeLabel = null;
15436  }
15437 
15438  fixed (int* nativeV = &v)
15439  {
15440  byte ret = ImGuiNative.igRadioButton_IntPtr(nativeLabel, nativeV, vButton);
15441  if (labelByteCount > Util.StackAllocationSizeLimit)
15442  {
15443  Util.Free(nativeLabel);
15444  }
15445 
15446  return ret != 0;
15447  }
15448  }
15449 
15453  public static void Render()
15454  {
15456  }
15457 
15461  public static void RenderPlatformWindowsDefault()
15462  {
15463  void* platformRenderArg = null;
15464  void* rendererRenderArg = null;
15465  ImGuiNative.igRenderPlatformWindowsDefault(platformRenderArg, rendererRenderArg);
15466  }
15467 
15472  public static void RenderPlatformWindowsDefault(IntPtr platformRenderArg)
15473  {
15474  void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15475  void* rendererRenderArg = null;
15476  ImGuiNative.igRenderPlatformWindowsDefault(nativePlatformRenderArg, rendererRenderArg);
15477  }
15478 
15484  public static void RenderPlatformWindowsDefault(IntPtr platformRenderArg, IntPtr rendererRenderArg)
15485  {
15486  void* nativePlatformRenderArg = platformRenderArg.ToPointer();
15487  void* nativeRendererRenderArg = rendererRenderArg.ToPointer();
15488  ImGuiNative.igRenderPlatformWindowsDefault(nativePlatformRenderArg, nativeRendererRenderArg);
15489  }
15490 
15494  public static void ResetMouseDragDelta()
15495  {
15496  ImGuiMouseButton button = 0;
15498  }
15499 
15504  public static void ResetMouseDragDelta(ImGuiMouseButton button)
15505  {
15507  }
15508 
15512  public static void SameLine()
15513  {
15514  float offsetFromStartX = 0.0f;
15515  float spacing = -1.0f;
15516  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15517  }
15518 
15523  public static void SameLine(float offsetFromStartX)
15524  {
15525  float spacing = -1.0f;
15526  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15527  }
15528 
15534  public static void SameLine(float offsetFromStartX, float spacing)
15535  {
15536  ImGuiNative.igSameLine(offsetFromStartX, spacing);
15537  }
15538 
15543  public static void SaveIniSettingsToDisk(string iniFilename)
15544  {
15545  byte* nativeIniFilename;
15546  int iniFilenameByteCount = 0;
15547  if (iniFilename != null)
15548  {
15549  iniFilenameByteCount = Encoding.UTF8.GetByteCount(iniFilename);
15550  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
15551  {
15552  nativeIniFilename = Util.Allocate(iniFilenameByteCount + 1);
15553  }
15554  else
15555  {
15556  byte* nativeIniFilenameStackBytes = stackalloc byte[iniFilenameByteCount + 1];
15557  nativeIniFilename = nativeIniFilenameStackBytes;
15558  }
15559 
15560  int nativeIniFilenameOffset = Util.GetUtf8(iniFilename, nativeIniFilename, iniFilenameByteCount);
15561  nativeIniFilename[nativeIniFilenameOffset] = 0;
15562  }
15563  else
15564  {
15565  nativeIniFilename = null;
15566  }
15567 
15568  ImGuiNative.igSaveIniSettingsToDisk(nativeIniFilename);
15569  if (iniFilenameByteCount > Util.StackAllocationSizeLimit)
15570  {
15571  Util.Free(nativeIniFilename);
15572  }
15573  }
15574 
15579  public static string SaveIniSettingsToMemory()
15580  {
15581  uint* outIniSize = null;
15582  byte* ret = ImGuiNative.igSaveIniSettingsToMemory(outIniSize);
15583  return Util.StringFromPtr(ret);
15584  }
15585 
15591  public static string SaveIniSettingsToMemory(out uint outIniSize)
15592  {
15593  fixed (uint* nativeOutIniSize = &outIniSize)
15594  {
15595  byte* ret = ImGuiNative.igSaveIniSettingsToMemory(nativeOutIniSize);
15596  return Util.StringFromPtr(ret);
15597  }
15598  }
15599 
15605  public static bool Selectable(string label)
15606  {
15607  byte* nativeLabel;
15608  int labelByteCount = 0;
15609  if (label != null)
15610  {
15611  labelByteCount = Encoding.UTF8.GetByteCount(label);
15612  if (labelByteCount > Util.StackAllocationSizeLimit)
15613  {
15614  nativeLabel = Util.Allocate(labelByteCount + 1);
15615  }
15616  else
15617  {
15618  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15619  nativeLabel = nativeLabelStackBytes;
15620  }
15621 
15622  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15623  nativeLabel[nativeLabelOffset] = 0;
15624  }
15625  else
15626  {
15627  nativeLabel = null;
15628  }
15629 
15630  byte selected = 0;
15631  ImGuiSelectables flag = 0;
15632  Vector2F size = new Vector2F();
15633  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, selected, flag, size);
15634  if (labelByteCount > Util.StackAllocationSizeLimit)
15635  {
15636  Util.Free(nativeLabel);
15637  }
15638 
15639  return ret != 0;
15640  }
15641 
15648  public static bool Selectable(string label, bool selected)
15649  {
15650  byte* nativeLabel;
15651  int labelByteCount = 0;
15652  if (label != null)
15653  {
15654  labelByteCount = Encoding.UTF8.GetByteCount(label);
15655  if (labelByteCount > Util.StackAllocationSizeLimit)
15656  {
15657  nativeLabel = Util.Allocate(labelByteCount + 1);
15658  }
15659  else
15660  {
15661  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15662  nativeLabel = nativeLabelStackBytes;
15663  }
15664 
15665  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15666  nativeLabel[nativeLabelOffset] = 0;
15667  }
15668  else
15669  {
15670  nativeLabel = null;
15671  }
15672 
15673  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15674  ImGuiSelectables flag = 0;
15675  Vector2F size = new Vector2F();
15676  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flag, size);
15677  if (labelByteCount > Util.StackAllocationSizeLimit)
15678  {
15679  Util.Free(nativeLabel);
15680  }
15681 
15682  return ret != 0;
15683  }
15684 
15692  public static bool Selectable(string label, bool selected, ImGuiSelectables flag)
15693  {
15694  byte* nativeLabel;
15695  int labelByteCount = 0;
15696  if (label != null)
15697  {
15698  labelByteCount = Encoding.UTF8.GetByteCount(label);
15699  if (labelByteCount > Util.StackAllocationSizeLimit)
15700  {
15701  nativeLabel = Util.Allocate(labelByteCount + 1);
15702  }
15703  else
15704  {
15705  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15706  nativeLabel = nativeLabelStackBytes;
15707  }
15708 
15709  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15710  nativeLabel[nativeLabelOffset] = 0;
15711  }
15712  else
15713  {
15714  nativeLabel = null;
15715  }
15716 
15717  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15718  Vector2F size = new Vector2F();
15719  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flag, size);
15720  if (labelByteCount > Util.StackAllocationSizeLimit)
15721  {
15722  Util.Free(nativeLabel);
15723  }
15724 
15725  return ret != 0;
15726  }
15727 
15736  public static bool Selectable(string label, bool selected, ImGuiSelectables flag, Vector2F size)
15737  {
15738  byte* nativeLabel;
15739  int labelByteCount = 0;
15740  if (label != null)
15741  {
15742  labelByteCount = Encoding.UTF8.GetByteCount(label);
15743  if (labelByteCount > Util.StackAllocationSizeLimit)
15744  {
15745  nativeLabel = Util.Allocate(labelByteCount + 1);
15746  }
15747  else
15748  {
15749  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15750  nativeLabel = nativeLabelStackBytes;
15751  }
15752 
15753  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15754  nativeLabel[nativeLabelOffset] = 0;
15755  }
15756  else
15757  {
15758  nativeLabel = null;
15759  }
15760 
15761  byte nativeSelected = selected ? (byte) 1 : (byte) 0;
15762  byte ret = ImGuiNative.igSelectable_Bool(nativeLabel, nativeSelected, flag, size);
15763  if (labelByteCount > Util.StackAllocationSizeLimit)
15764  {
15765  Util.Free(nativeLabel);
15766  }
15767 
15768  return ret != 0;
15769  }
15770 
15777  public static bool Selectable(string label, ref bool pSelected)
15778  {
15779  byte* nativeLabel;
15780  int labelByteCount = 0;
15781  if (label != null)
15782  {
15783  labelByteCount = Encoding.UTF8.GetByteCount(label);
15784  if (labelByteCount > Util.StackAllocationSizeLimit)
15785  {
15786  nativeLabel = Util.Allocate(labelByteCount + 1);
15787  }
15788  else
15789  {
15790  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15791  nativeLabel = nativeLabelStackBytes;
15792  }
15793 
15794  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15795  nativeLabel[nativeLabelOffset] = 0;
15796  }
15797  else
15798  {
15799  nativeLabel = null;
15800  }
15801 
15802  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15803  byte* nativePSelected = &nativePSelectedVal;
15804  ImGuiSelectables flag = 0;
15805  Vector2F size = new Vector2F();
15806  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flag, size);
15807  if (labelByteCount > Util.StackAllocationSizeLimit)
15808  {
15809  Util.Free(nativeLabel);
15810  }
15811 
15812  pSelected = nativePSelectedVal != 0;
15813  return ret != 0;
15814  }
15815 
15823  public static bool Selectable(string label, ref bool pSelected, ImGuiSelectables flag)
15824  {
15825  byte* nativeLabel;
15826  int labelByteCount = 0;
15827  if (label != null)
15828  {
15829  labelByteCount = Encoding.UTF8.GetByteCount(label);
15830  if (labelByteCount > Util.StackAllocationSizeLimit)
15831  {
15832  nativeLabel = Util.Allocate(labelByteCount + 1);
15833  }
15834  else
15835  {
15836  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15837  nativeLabel = nativeLabelStackBytes;
15838  }
15839 
15840  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15841  nativeLabel[nativeLabelOffset] = 0;
15842  }
15843  else
15844  {
15845  nativeLabel = null;
15846  }
15847 
15848  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15849  byte* nativePSelected = &nativePSelectedVal;
15850  Vector2F size = new Vector2F();
15851  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flag, size);
15852  if (labelByteCount > Util.StackAllocationSizeLimit)
15853  {
15854  Util.Free(nativeLabel);
15855  }
15856 
15857  pSelected = nativePSelectedVal != 0;
15858  return ret != 0;
15859  }
15860 
15869  public static bool Selectable(string label, ref bool pSelected, ImGuiSelectables flag, Vector2F size)
15870  {
15871  byte* nativeLabel;
15872  int labelByteCount = 0;
15873  if (label != null)
15874  {
15875  labelByteCount = Encoding.UTF8.GetByteCount(label);
15876  if (labelByteCount > Util.StackAllocationSizeLimit)
15877  {
15878  nativeLabel = Util.Allocate(labelByteCount + 1);
15879  }
15880  else
15881  {
15882  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15883  nativeLabel = nativeLabelStackBytes;
15884  }
15885 
15886  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15887  nativeLabel[nativeLabelOffset] = 0;
15888  }
15889  else
15890  {
15891  nativeLabel = null;
15892  }
15893 
15894  byte nativePSelectedVal = pSelected ? (byte) 1 : (byte) 0;
15895  byte* nativePSelected = &nativePSelectedVal;
15896  byte ret = ImGuiNative.igSelectable_BoolPtr(nativeLabel, nativePSelected, flag, size);
15897  if (labelByteCount > Util.StackAllocationSizeLimit)
15898  {
15899  Util.Free(nativeLabel);
15900  }
15901 
15902  pSelected = nativePSelectedVal != 0;
15903  return ret != 0;
15904  }
15905 
15909  public static void Separator()
15910  {
15912  }
15913 
15918  public static void SeparatorText(string label)
15919  {
15920  byte* nativeLabel;
15921  int labelByteCount = 0;
15922  if (label != null)
15923  {
15924  labelByteCount = Encoding.UTF8.GetByteCount(label);
15925  if (labelByteCount > Util.StackAllocationSizeLimit)
15926  {
15927  nativeLabel = Util.Allocate(labelByteCount + 1);
15928  }
15929  else
15930  {
15931  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
15932  nativeLabel = nativeLabelStackBytes;
15933  }
15934 
15935  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
15936  nativeLabel[nativeLabelOffset] = 0;
15937  }
15938  else
15939  {
15940  nativeLabel = null;
15941  }
15942 
15943  ImGuiNative.igSeparatorText(nativeLabel);
15944  if (labelByteCount > Util.StackAllocationSizeLimit)
15945  {
15946  Util.Free(nativeLabel);
15947  }
15948  }
15949 
15955  public static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc)
15956  {
15957  void* userData = null;
15958  ImGuiNative.igSetAllocatorFunctions(allocFunc, freeFunc, userData);
15959  }
15960 
15967  public static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, IntPtr userData)
15968  {
15969  void* nativeUserData = userData.ToPointer();
15970  ImGuiNative.igSetAllocatorFunctions(allocFunc, freeFunc, nativeUserData);
15971  }
15972 
15977  public static void SetClipboardText(string text)
15978  {
15979  byte* nativeText;
15980  int textByteCount = 0;
15981  if (text != null)
15982  {
15983  textByteCount = Encoding.UTF8.GetByteCount(text);
15984  if (textByteCount > Util.StackAllocationSizeLimit)
15985  {
15986  nativeText = Util.Allocate(textByteCount + 1);
15987  }
15988  else
15989  {
15990  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
15991  nativeText = nativeTextStackBytes;
15992  }
15993 
15994  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
15995  nativeText[nativeTextOffset] = 0;
15996  }
15997  else
15998  {
15999  nativeText = null;
16000  }
16001 
16002  ImGuiNative.igSetClipboardText(nativeText);
16003  if (textByteCount > Util.StackAllocationSizeLimit)
16004  {
16005  Util.Free(nativeText);
16006  }
16007  }
16008 
16013  public static void SetColorEditOptions(ImGuiColorEdits flag)
16014  {
16016  }
16017 
16023  public static void SetColumnOffset(int columnIndex, float offsetX)
16024  {
16025  ImGuiNative.igSetColumnOffset(columnIndex, offsetX);
16026  }
16027 
16033  public static void SetColumnWidth(int columnIndex, float width)
16034  {
16035  ImGuiNative.igSetColumnWidth(columnIndex, width);
16036  }
16037 
16042  public static void SetCurrentContext(IntPtr ctx)
16043  {
16045  }
16046 
16051  public static void SetCursorPos(Vector2F localPos)
16052  {
16053  ImGuiNative.igSetCursorPos(localPos);
16054  }
16055 
16060  public static void SetCursorPosX(float localX)
16061  {
16062  ImGuiNative.igSetCursorPosX(localX);
16063  }
16064 
16069  public static void SetCursorPosY(float localY)
16070  {
16071  ImGuiNative.igSetCursorPosY(localY);
16072  }
16073 
16078  public static void SetCursorScreenPos(Vector2F pos)
16079  {
16081  }
16082 
16090  public static bool SetDragDropPayload(string type, IntPtr data, uint sz)
16091  {
16092  byte* nativeType;
16093  int typeByteCount = 0;
16094  if (type != null)
16095  {
16096  typeByteCount = Encoding.UTF8.GetByteCount(type);
16097  if (typeByteCount > Util.StackAllocationSizeLimit)
16098  {
16099  nativeType = Util.Allocate(typeByteCount + 1);
16100  }
16101  else
16102  {
16103  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
16104  nativeType = nativeTypeStackBytes;
16105  }
16106 
16107  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
16108  nativeType[nativeTypeOffset] = 0;
16109  }
16110  else
16111  {
16112  nativeType = null;
16113  }
16114 
16115  void* nativeData = data.ToPointer();
16116  ImGuiCond cond = 0;
16117  byte ret = ImGuiNative.igSetDragDropPayload(nativeType, nativeData, sz, cond);
16118  if (typeByteCount > Util.StackAllocationSizeLimit)
16119  {
16120  Util.Free(nativeType);
16121  }
16122 
16123  return ret != 0;
16124  }
16125 
16134  public static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
16135  {
16136  byte* nativeType;
16137  int typeByteCount = 0;
16138  if (type != null)
16139  {
16140  typeByteCount = Encoding.UTF8.GetByteCount(type);
16141  if (typeByteCount > Util.StackAllocationSizeLimit)
16142  {
16143  nativeType = Util.Allocate(typeByteCount + 1);
16144  }
16145  else
16146  {
16147  byte* nativeTypeStackBytes = stackalloc byte[typeByteCount + 1];
16148  nativeType = nativeTypeStackBytes;
16149  }
16150 
16151  int nativeTypeOffset = Util.GetUtf8(type, nativeType, typeByteCount);
16152  nativeType[nativeTypeOffset] = 0;
16153  }
16154  else
16155  {
16156  nativeType = null;
16157  }
16158 
16159  void* nativeData = data.ToPointer();
16160  byte ret = ImGuiNative.igSetDragDropPayload(nativeType, nativeData, sz, cond);
16161  if (typeByteCount > Util.StackAllocationSizeLimit)
16162  {
16163  Util.Free(nativeType);
16164  }
16165 
16166  return ret != 0;
16167  }
16168 
16172  public static void SetItemAllowOverlap()
16173  {
16175  }
16176 
16180  public static void SetItemDefaultFocus()
16181  {
16183  }
16184 
16188  public static void SetKeyboardFocusHere()
16189  {
16190  int offset = 0;
16192  }
16193 
16198  public static void SetKeyboardFocusHere(int offset)
16199  {
16201  }
16202 
16207  public static void SetMouseCursor(ImGuiMouseCursor cursorType)
16208  {
16209  ImGuiNative.igSetMouseCursor(cursorType);
16210  }
16211 
16216  public static void SetNextFrameWantCaptureKeyboard(bool wantCaptureKeyboard)
16217  {
16218  byte nativeWantCaptureKeyboard = wantCaptureKeyboard ? (byte) 1 : (byte) 0;
16219  ImGuiNative.igSetNextFrameWantCaptureKeyboard(nativeWantCaptureKeyboard);
16220  }
16221 
16226  public static void SetNextFrameWantCaptureMouse(bool wantCaptureMouse)
16227  {
16228  byte nativeWantCaptureMouse = wantCaptureMouse ? (byte) 1 : (byte) 0;
16229  ImGuiNative.igSetNextFrameWantCaptureMouse(nativeWantCaptureMouse);
16230  }
16231 
16236  public static void SetNextItemOpen(bool isOpen)
16237  {
16238  byte nativeIsOpen = isOpen ? (byte) 1 : (byte) 0;
16239  ImGuiCond cond = 0;
16240  ImGuiNative.igSetNextItemOpen(nativeIsOpen, cond);
16241  }
16242 
16248  public static void SetNextItemOpen(bool isOpen, ImGuiCond cond)
16249  {
16250  byte nativeIsOpen = isOpen ? (byte) 1 : (byte) 0;
16251  ImGuiNative.igSetNextItemOpen(nativeIsOpen, cond);
16252  }
16253 
16258  public static void SetNextItemWidth(float itemWidth)
16259  {
16260  ImGuiNative.igSetNextItemWidth(itemWidth);
16261  }
16262 
16267  public static void SetNextWindowBgAlpha(float alpha)
16268  {
16270  }
16271 
16276  public static void SetNextWindowClass(ImGuiWindowClassPtr windowClass)
16277  {
16278  ImGuiWindowClass* nativeWindowClass = windowClass.NativePtr;
16279  ImGuiNative.igSetNextWindowClass(nativeWindowClass);
16280  }
16281 
16286  public static void SetNextWindowCollapsed(bool collapsed)
16287  {
16288  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16289  ImGuiCond cond = 0;
16290  ImGuiNative.igSetNextWindowCollapsed(nativeCollapsed, cond);
16291  }
16292 
16298  public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
16299  {
16300  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16301  ImGuiNative.igSetNextWindowCollapsed(nativeCollapsed, cond);
16302  }
16303 
16308  public static void SetNextWindowContentSize(Vector2F size)
16309  {
16311  }
16312 
16317  public static void SetNextWindowDockId(uint dockId)
16318  {
16319  ImGuiCond cond = 0;
16320  ImGuiNative.igSetNextWindowDockID(dockId, cond);
16321  }
16322 
16328  public static void SetNextWindowDockId(uint dockId, ImGuiCond cond)
16329  {
16330  ImGuiNative.igSetNextWindowDockID(dockId, cond);
16331  }
16332 
16336  public static void SetNextWindowFocus()
16337  {
16339  }
16340 
16345  public static void SetNextWindowPos(Vector2F pos)
16346  {
16347  ImGuiCond cond = 0;
16348  Vector2F pivot = new Vector2F();
16349  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16350  }
16351 
16357  public static void SetNextWindowPos(Vector2F pos, ImGuiCond cond)
16358  {
16359  Vector2F pivot = new Vector2F();
16360  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16361  }
16362 
16369  public static void SetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
16370  {
16371  ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
16372  }
16373 
16378  public static void SetNextWindowScroll(Vector2F scroll)
16379  {
16381  }
16382 
16387  public static void SetNextWindowSize(Vector2F size)
16388  {
16389  ImGuiCond cond = 0;
16390  ImGuiNative.igSetNextWindowSize(size, cond);
16391  }
16392 
16398  public static void SetNextWindowSize(Vector2F size, ImGuiCond cond)
16399  {
16400  ImGuiNative.igSetNextWindowSize(size, cond);
16401  }
16402 
16408  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax)
16409  {
16410  ImGuiSizeCallback customCallback = null;
16411  void* customCallbackData = null;
16412  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, customCallbackData);
16413  }
16414 
16421  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback)
16422  {
16423  void* customCallbackData = null;
16424  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, customCallbackData);
16425  }
16426 
16434  public static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, IntPtr customCallbackData)
16435  {
16436  void* nativeCustomCallbackData = customCallbackData.ToPointer();
16437  ImGuiNative.igSetNextWindowSizeConstraints(sizeMin, sizeMax, customCallback, nativeCustomCallbackData);
16438  }
16439 
16444  public static void SetNextWindowViewport(uint viewportId)
16445  {
16447  }
16448 
16453  public static void SetScrollFromPosX(float localX)
16454  {
16455  float centerXRatio = 0.5f;
16456  ImGuiNative.igSetScrollFromPosX_Float(localX, centerXRatio);
16457  }
16458 
16464  public static void SetScrollFromPosX(float localX, float centerXRatio)
16465  {
16466  ImGuiNative.igSetScrollFromPosX_Float(localX, centerXRatio);
16467  }
16468 
16473  public static void SetScrollFromPosY(float localY)
16474  {
16475  float centerYRatio = 0.5f;
16476  ImGuiNative.igSetScrollFromPosY_Float(localY, centerYRatio);
16477  }
16478 
16484  public static void SetScrollFromPosY(float localY, float centerYRatio)
16485  {
16486  ImGuiNative.igSetScrollFromPosY_Float(localY, centerYRatio);
16487  }
16488 
16492  public static void SetScrollHereX()
16493  {
16494  float centerXRatio = 0.5f;
16495  ImGuiNative.igSetScrollHereX(centerXRatio);
16496  }
16497 
16502  public static void SetScrollHereX(float centerXRatio)
16503  {
16504  ImGuiNative.igSetScrollHereX(centerXRatio);
16505  }
16506 
16510  public static void SetScrollHereY()
16511  {
16512  float centerYRatio = 0.5f;
16513  ImGuiNative.igSetScrollHereY(centerYRatio);
16514  }
16515 
16520  public static void SetScrollHereY(float centerYRatio)
16521  {
16522  ImGuiNative.igSetScrollHereY(centerYRatio);
16523  }
16524 
16529  public static void SetScrollX(float scrollX)
16530  {
16532  }
16533 
16538  public static void SetScrollY(float scrollY)
16539  {
16541  }
16542 
16547  public static void SetStateStorage(ImGuiStoragePtr storage)
16548  {
16549  ImGuiStorage* nativeStorage = storage.NativePtr;
16550  ImGuiNative.igSetStateStorage(nativeStorage);
16551  }
16552 
16557  public static void SetTabItemClosed(string tabOrDockedWindowLabel)
16558  {
16559  byte* nativeTabOrDockedWindowLabel;
16560  int tabOrDockedWindowLabelByteCount = 0;
16561  if (tabOrDockedWindowLabel != null)
16562  {
16563  tabOrDockedWindowLabelByteCount = Encoding.UTF8.GetByteCount(tabOrDockedWindowLabel);
16564  if (tabOrDockedWindowLabelByteCount > Util.StackAllocationSizeLimit)
16565  {
16566  nativeTabOrDockedWindowLabel = Util.Allocate(tabOrDockedWindowLabelByteCount + 1);
16567  }
16568  else
16569  {
16570  byte* nativeTabOrDockedWindowLabelStackBytes = stackalloc byte[tabOrDockedWindowLabelByteCount + 1];
16571  nativeTabOrDockedWindowLabel = nativeTabOrDockedWindowLabelStackBytes;
16572  }
16573 
16574  int nativeTabOrDockedWindowLabelOffset = Util.GetUtf8(tabOrDockedWindowLabel, nativeTabOrDockedWindowLabel, tabOrDockedWindowLabelByteCount);
16575  nativeTabOrDockedWindowLabel[nativeTabOrDockedWindowLabelOffset] = 0;
16576  }
16577  else
16578  {
16579  nativeTabOrDockedWindowLabel = null;
16580  }
16581 
16582  ImGuiNative.igSetTabItemClosed(nativeTabOrDockedWindowLabel);
16583  if (tabOrDockedWindowLabelByteCount > Util.StackAllocationSizeLimit)
16584  {
16585  Util.Free(nativeTabOrDockedWindowLabel);
16586  }
16587  }
16588 
16593  public static void SetTooltip(string fmt)
16594  {
16595  byte* nativeFmt;
16596  int fmtByteCount = 0;
16597  if (fmt != null)
16598  {
16599  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
16600  if (fmtByteCount > Util.StackAllocationSizeLimit)
16601  {
16602  nativeFmt = Util.Allocate(fmtByteCount + 1);
16603  }
16604  else
16605  {
16606  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
16607  nativeFmt = nativeFmtStackBytes;
16608  }
16609 
16610  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
16611  nativeFmt[nativeFmtOffset] = 0;
16612  }
16613  else
16614  {
16615  nativeFmt = null;
16616  }
16617 
16618  ImGuiNative.igSetTooltip(nativeFmt);
16619  if (fmtByteCount > Util.StackAllocationSizeLimit)
16620  {
16621  Util.Free(nativeFmt);
16622  }
16623  }
16624 
16629  public static void SetWindowCollapsed(bool collapsed)
16630  {
16631  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16632  ImGuiCond cond = 0;
16633  ImGuiNative.igSetWindowCollapsed_Bool(nativeCollapsed, cond);
16634  }
16635 
16641  public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
16642  {
16643  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16644  ImGuiNative.igSetWindowCollapsed_Bool(nativeCollapsed, cond);
16645  }
16646 
16652  public static void SetWindowCollapsed(string name, bool collapsed)
16653  {
16654  byte* nativeName;
16655  int nameByteCount = 0;
16656  if (name != null)
16657  {
16658  nameByteCount = Encoding.UTF8.GetByteCount(name);
16659  if (nameByteCount > Util.StackAllocationSizeLimit)
16660  {
16661  nativeName = Util.Allocate(nameByteCount + 1);
16662  }
16663  else
16664  {
16665  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16666  nativeName = nativeNameStackBytes;
16667  }
16668 
16669  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16670  nativeName[nativeNameOffset] = 0;
16671  }
16672  else
16673  {
16674  nativeName = null;
16675  }
16676 
16677  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16678  ImGuiCond cond = 0;
16679  ImGuiNative.igSetWindowCollapsed_Str(nativeName, nativeCollapsed, cond);
16680  if (nameByteCount > Util.StackAllocationSizeLimit)
16681  {
16682  Util.Free(nativeName);
16683  }
16684  }
16685 
16692  public static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
16693  {
16694  byte* nativeName;
16695  int nameByteCount = 0;
16696  if (name != null)
16697  {
16698  nameByteCount = Encoding.UTF8.GetByteCount(name);
16699  if (nameByteCount > Util.StackAllocationSizeLimit)
16700  {
16701  nativeName = Util.Allocate(nameByteCount + 1);
16702  }
16703  else
16704  {
16705  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16706  nativeName = nativeNameStackBytes;
16707  }
16708 
16709  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16710  nativeName[nativeNameOffset] = 0;
16711  }
16712  else
16713  {
16714  nativeName = null;
16715  }
16716 
16717  byte nativeCollapsed = collapsed ? (byte) 1 : (byte) 0;
16718  ImGuiNative.igSetWindowCollapsed_Str(nativeName, nativeCollapsed, cond);
16719  if (nameByteCount > Util.StackAllocationSizeLimit)
16720  {
16721  Util.Free(nativeName);
16722  }
16723  }
16724 
16728  public static void SetWindowFocus()
16729  {
16731  }
16732 
16737  public static void SetWindowFocus(string name)
16738  {
16739  byte* nativeName;
16740  int nameByteCount = 0;
16741  if (name != null)
16742  {
16743  nameByteCount = Encoding.UTF8.GetByteCount(name);
16744  if (nameByteCount > Util.StackAllocationSizeLimit)
16745  {
16746  nativeName = Util.Allocate(nameByteCount + 1);
16747  }
16748  else
16749  {
16750  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16751  nativeName = nativeNameStackBytes;
16752  }
16753 
16754  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16755  nativeName[nativeNameOffset] = 0;
16756  }
16757  else
16758  {
16759  nativeName = null;
16760  }
16761 
16762  ImGuiNative.igSetWindowFocus_Str(nativeName);
16763  if (nameByteCount > Util.StackAllocationSizeLimit)
16764  {
16765  Util.Free(nativeName);
16766  }
16767  }
16768 
16773  public static void SetWindowFontScale(float scale)
16774  {
16776  }
16777 
16782  public static void SetWindowPos(Vector2F pos)
16783  {
16784  ImGuiCond cond = 0;
16785  ImGuiNative.igSetWindowPos_Vec2(pos, cond);
16786  }
16787 
16793  public static void SetWindowPos(Vector2F pos, ImGuiCond cond)
16794  {
16795  ImGuiNative.igSetWindowPos_Vec2(pos, cond);
16796  }
16797 
16803  public static void SetWindowPos(string name, Vector2F pos)
16804  {
16805  byte* nativeName;
16806  int nameByteCount = 0;
16807  if (name != null)
16808  {
16809  nameByteCount = Encoding.UTF8.GetByteCount(name);
16810  if (nameByteCount > Util.StackAllocationSizeLimit)
16811  {
16812  nativeName = Util.Allocate(nameByteCount + 1);
16813  }
16814  else
16815  {
16816  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16817  nativeName = nativeNameStackBytes;
16818  }
16819 
16820  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16821  nativeName[nativeNameOffset] = 0;
16822  }
16823  else
16824  {
16825  nativeName = null;
16826  }
16827 
16828  ImGuiCond cond = 0;
16829  ImGuiNative.igSetWindowPos_Str(nativeName, pos, cond);
16830  if (nameByteCount > Util.StackAllocationSizeLimit)
16831  {
16832  Util.Free(nativeName);
16833  }
16834  }
16835 
16842  public static void SetWindowPos(string name, Vector2F pos, ImGuiCond cond)
16843  {
16844  byte* nativeName;
16845  int nameByteCount = 0;
16846  if (name != null)
16847  {
16848  nameByteCount = Encoding.UTF8.GetByteCount(name);
16849  if (nameByteCount > Util.StackAllocationSizeLimit)
16850  {
16851  nativeName = Util.Allocate(nameByteCount + 1);
16852  }
16853  else
16854  {
16855  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16856  nativeName = nativeNameStackBytes;
16857  }
16858 
16859  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16860  nativeName[nativeNameOffset] = 0;
16861  }
16862  else
16863  {
16864  nativeName = null;
16865  }
16866 
16867  ImGuiNative.igSetWindowPos_Str(nativeName, pos, cond);
16868  if (nameByteCount > Util.StackAllocationSizeLimit)
16869  {
16870  Util.Free(nativeName);
16871  }
16872  }
16873 
16878  public static void SetWindowSize(Vector2F size)
16879  {
16880  ImGuiCond cond = 0;
16881  ImGuiNative.igSetWindowSize_Vec2(size, cond);
16882  }
16883 
16889  public static void SetWindowSize(Vector2F size, ImGuiCond cond)
16890  {
16891  ImGuiNative.igSetWindowSize_Vec2(size, cond);
16892  }
16893 
16899  public static void SetWindowSize(string name, Vector2F size)
16900  {
16901  byte* nativeName;
16902  int nameByteCount = 0;
16903  if (name != null)
16904  {
16905  nameByteCount = Encoding.UTF8.GetByteCount(name);
16906  if (nameByteCount > Util.StackAllocationSizeLimit)
16907  {
16908  nativeName = Util.Allocate(nameByteCount + 1);
16909  }
16910  else
16911  {
16912  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16913  nativeName = nativeNameStackBytes;
16914  }
16915 
16916  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16917  nativeName[nativeNameOffset] = 0;
16918  }
16919  else
16920  {
16921  nativeName = null;
16922  }
16923 
16924  ImGuiCond cond = 0;
16925  ImGuiNative.igSetWindowSize_Str(nativeName, size, cond);
16926  if (nameByteCount > Util.StackAllocationSizeLimit)
16927  {
16928  Util.Free(nativeName);
16929  }
16930  }
16931 
16938  public static void SetWindowSize(string name, Vector2F size, ImGuiCond cond)
16939  {
16940  byte* nativeName;
16941  int nameByteCount = 0;
16942  if (name != null)
16943  {
16944  nameByteCount = Encoding.UTF8.GetByteCount(name);
16945  if (nameByteCount > Util.StackAllocationSizeLimit)
16946  {
16947  nativeName = Util.Allocate(nameByteCount + 1);
16948  }
16949  else
16950  {
16951  byte* nativeNameStackBytes = stackalloc byte[nameByteCount + 1];
16952  nativeName = nativeNameStackBytes;
16953  }
16954 
16955  int nativeNameOffset = Util.GetUtf8(name, nativeName, nameByteCount);
16956  nativeName[nativeNameOffset] = 0;
16957  }
16958  else
16959  {
16960  nativeName = null;
16961  }
16962 
16963  ImGuiNative.igSetWindowSize_Str(nativeName, size, cond);
16964  if (nameByteCount > Util.StackAllocationSizeLimit)
16965  {
16966  Util.Free(nativeName);
16967  }
16968  }
16969 
16973  public static void ShowAboutWindow()
16974  {
16975  byte* pOpen = null;
16977  }
16978 
16983  public static void ShowAboutWindow(ref bool pOpen)
16984  {
16985  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
16986  byte* nativePOpen = &nativePOpenVal;
16987  ImGuiNative.igShowAboutWindow(nativePOpen);
16988  pOpen = nativePOpenVal != 0;
16989  }
16990 
16994  public static void ShowDebugLogWindow()
16995  {
16996  byte* pOpen = null;
16998  }
16999 
17004  public static void ShowDebugLogWindow(ref bool pOpen)
17005  {
17006  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17007  byte* nativePOpen = &nativePOpenVal;
17008  ImGuiNative.igShowDebugLogWindow(nativePOpen);
17009  pOpen = nativePOpenVal != 0;
17010  }
17011 
17015  public static void ShowDemoWindow()
17016  {
17017  byte* pOpen = null;
17019  }
17020 
17025  public static void ShowDemoWindow(ref bool pOpen)
17026  {
17027  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17028  byte* nativePOpen = &nativePOpenVal;
17029  ImGuiNative.igShowDemoWindow(nativePOpen);
17030  pOpen = nativePOpenVal != 0;
17031  }
17032 
17037  public static void ShowFontSelector(string label)
17038  {
17039  byte* nativeLabel;
17040  int labelByteCount = 0;
17041  if (label != null)
17042  {
17043  labelByteCount = Encoding.UTF8.GetByteCount(label);
17044  if (labelByteCount > Util.StackAllocationSizeLimit)
17045  {
17046  nativeLabel = Util.Allocate(labelByteCount + 1);
17047  }
17048  else
17049  {
17050  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17051  nativeLabel = nativeLabelStackBytes;
17052  }
17053 
17054  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17055  nativeLabel[nativeLabelOffset] = 0;
17056  }
17057  else
17058  {
17059  nativeLabel = null;
17060  }
17061 
17062  ImGuiNative.igShowFontSelector(nativeLabel);
17063  if (labelByteCount > Util.StackAllocationSizeLimit)
17064  {
17065  Util.Free(nativeLabel);
17066  }
17067  }
17068 
17072  public static void ShowMetricsWindow()
17073  {
17074  byte* pOpen = null;
17076  }
17077 
17082  public static void ShowMetricsWindow(ref bool pOpen)
17083  {
17084  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17085  byte* nativePOpen = &nativePOpenVal;
17086  ImGuiNative.igShowMetricsWindow(nativePOpen);
17087  pOpen = nativePOpenVal != 0;
17088  }
17089 
17093  public static void ShowStackToolWindow()
17094  {
17095  byte* pOpen = null;
17097  }
17098 
17103  public static void ShowStackToolWindow(ref bool pOpen)
17104  {
17105  byte nativePOpenVal = pOpen ? (byte) 1 : (byte) 0;
17106  byte* nativePOpen = &nativePOpenVal;
17107  ImGuiNative.igShowStackToolWindow(nativePOpen);
17108  pOpen = nativePOpenVal != 0;
17109  }
17110 
17114  public static void ShowStyleEditor()
17115  {
17116  ImGuiStyle* @ref = null;
17118  }
17119 
17123  public static void ShowStyleEditor(ImGuiStylePtr @ref)
17124  {
17125  ImGuiStyle* nativeRef = @ref.NativePtr;
17126  ImGuiNative.igShowStyleEditor(nativeRef);
17127  }
17128 
17134  public static bool ShowStyleSelector(string label)
17135  {
17136  byte* nativeLabel;
17137  int labelByteCount = 0;
17138  if (label != null)
17139  {
17140  labelByteCount = Encoding.UTF8.GetByteCount(label);
17141  if (labelByteCount > Util.StackAllocationSizeLimit)
17142  {
17143  nativeLabel = Util.Allocate(labelByteCount + 1);
17144  }
17145  else
17146  {
17147  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17148  nativeLabel = nativeLabelStackBytes;
17149  }
17150 
17151  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17152  nativeLabel[nativeLabelOffset] = 0;
17153  }
17154  else
17155  {
17156  nativeLabel = null;
17157  }
17158 
17159  byte ret = ImGuiNative.igShowStyleSelector(nativeLabel);
17160  if (labelByteCount > Util.StackAllocationSizeLimit)
17161  {
17162  Util.Free(nativeLabel);
17163  }
17164 
17165  return ret != 0;
17166  }
17167 
17171  public static void ShowUserGuide()
17172  {
17174  }
17175 
17182  public static bool SliderAngle(string label, ref float vRad)
17183  {
17184  byte* nativeLabel;
17185  int labelByteCount = 0;
17186  if (label != null)
17187  {
17188  labelByteCount = Encoding.UTF8.GetByteCount(label);
17189  if (labelByteCount > Util.StackAllocationSizeLimit)
17190  {
17191  nativeLabel = Util.Allocate(labelByteCount + 1);
17192  }
17193  else
17194  {
17195  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17196  nativeLabel = nativeLabelStackBytes;
17197  }
17198 
17199  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17200  nativeLabel[nativeLabelOffset] = 0;
17201  }
17202  else
17203  {
17204  nativeLabel = null;
17205  }
17206 
17207  float vDegreesMin = -360.0f;
17208  float vDegreesMax = +360.0f;
17209  byte* nativeFormat;
17210  int formatByteCount = 0;
17211  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17212  if (formatByteCount > Util.StackAllocationSizeLimit)
17213  {
17214  nativeFormat = Util.Allocate(formatByteCount + 1);
17215  }
17216  else
17217  {
17218  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17219  nativeFormat = nativeFormatStackBytes;
17220  }
17221 
17222  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17223  nativeFormat[nativeFormatOffset] = 0;
17224  ImGuiSliders flag = 0;
17225  fixed (float* nativeVRad = &vRad)
17226  {
17227  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flag);
17228  if (labelByteCount > Util.StackAllocationSizeLimit)
17229  {
17230  Util.Free(nativeLabel);
17231  }
17232 
17233  if (formatByteCount > Util.StackAllocationSizeLimit)
17234  {
17235  Util.Free(nativeFormat);
17236  }
17237 
17238  return ret != 0;
17239  }
17240  }
17241 
17249  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin)
17250  {
17251  byte* nativeLabel;
17252  int labelByteCount = 0;
17253  if (label != null)
17254  {
17255  labelByteCount = Encoding.UTF8.GetByteCount(label);
17256  if (labelByteCount > Util.StackAllocationSizeLimit)
17257  {
17258  nativeLabel = Util.Allocate(labelByteCount + 1);
17259  }
17260  else
17261  {
17262  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17263  nativeLabel = nativeLabelStackBytes;
17264  }
17265 
17266  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17267  nativeLabel[nativeLabelOffset] = 0;
17268  }
17269  else
17270  {
17271  nativeLabel = null;
17272  }
17273 
17274  float vDegreesMax = +360.0f;
17275  byte* nativeFormat;
17276  int formatByteCount = 0;
17277  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17278  if (formatByteCount > Util.StackAllocationSizeLimit)
17279  {
17280  nativeFormat = Util.Allocate(formatByteCount + 1);
17281  }
17282  else
17283  {
17284  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17285  nativeFormat = nativeFormatStackBytes;
17286  }
17287 
17288  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17289  nativeFormat[nativeFormatOffset] = 0;
17290  ImGuiSliders flag = 0;
17291  fixed (float* nativeVRad = &vRad)
17292  {
17293  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flag);
17294  if (labelByteCount > Util.StackAllocationSizeLimit)
17295  {
17296  Util.Free(nativeLabel);
17297  }
17298 
17299  if (formatByteCount > Util.StackAllocationSizeLimit)
17300  {
17301  Util.Free(nativeFormat);
17302  }
17303 
17304  return ret != 0;
17305  }
17306  }
17307 
17316  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax)
17317  {
17318  byte* nativeLabel;
17319  int labelByteCount = 0;
17320  if (label != null)
17321  {
17322  labelByteCount = Encoding.UTF8.GetByteCount(label);
17323  if (labelByteCount > Util.StackAllocationSizeLimit)
17324  {
17325  nativeLabel = Util.Allocate(labelByteCount + 1);
17326  }
17327  else
17328  {
17329  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17330  nativeLabel = nativeLabelStackBytes;
17331  }
17332 
17333  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17334  nativeLabel[nativeLabelOffset] = 0;
17335  }
17336  else
17337  {
17338  nativeLabel = null;
17339  }
17340 
17341  byte* nativeFormat;
17342  int formatByteCount = 0;
17343  formatByteCount = Encoding.UTF8.GetByteCount("%.0f deg");
17344  if (formatByteCount > Util.StackAllocationSizeLimit)
17345  {
17346  nativeFormat = Util.Allocate(formatByteCount + 1);
17347  }
17348  else
17349  {
17350  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17351  nativeFormat = nativeFormatStackBytes;
17352  }
17353 
17354  int nativeFormatOffset = Util.GetUtf8("%.0f deg", nativeFormat, formatByteCount);
17355  nativeFormat[nativeFormatOffset] = 0;
17356  ImGuiSliders flag = 0;
17357  fixed (float* nativeVRad = &vRad)
17358  {
17359  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flag);
17360  if (labelByteCount > Util.StackAllocationSizeLimit)
17361  {
17362  Util.Free(nativeLabel);
17363  }
17364 
17365  if (formatByteCount > Util.StackAllocationSizeLimit)
17366  {
17367  Util.Free(nativeFormat);
17368  }
17369 
17370  return ret != 0;
17371  }
17372  }
17373 
17383  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format)
17384  {
17385  byte* nativeLabel;
17386  int labelByteCount = 0;
17387  if (label != null)
17388  {
17389  labelByteCount = Encoding.UTF8.GetByteCount(label);
17390  if (labelByteCount > Util.StackAllocationSizeLimit)
17391  {
17392  nativeLabel = Util.Allocate(labelByteCount + 1);
17393  }
17394  else
17395  {
17396  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17397  nativeLabel = nativeLabelStackBytes;
17398  }
17399 
17400  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17401  nativeLabel[nativeLabelOffset] = 0;
17402  }
17403  else
17404  {
17405  nativeLabel = null;
17406  }
17407 
17408  byte* nativeFormat;
17409  int formatByteCount = 0;
17410  if (format != null)
17411  {
17412  formatByteCount = Encoding.UTF8.GetByteCount(format);
17413  if (formatByteCount > Util.StackAllocationSizeLimit)
17414  {
17415  nativeFormat = Util.Allocate(formatByteCount + 1);
17416  }
17417  else
17418  {
17419  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17420  nativeFormat = nativeFormatStackBytes;
17421  }
17422 
17423  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17424  nativeFormat[nativeFormatOffset] = 0;
17425  }
17426  else
17427  {
17428  nativeFormat = null;
17429  }
17430 
17431  ImGuiSliders flag = 0;
17432  fixed (float* nativeVRad = &vRad)
17433  {
17434  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flag);
17435  if (labelByteCount > Util.StackAllocationSizeLimit)
17436  {
17437  Util.Free(nativeLabel);
17438  }
17439 
17440  if (formatByteCount > Util.StackAllocationSizeLimit)
17441  {
17442  Util.Free(nativeFormat);
17443  }
17444 
17445  return ret != 0;
17446  }
17447  }
17448 
17459  public static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format, ImGuiSliders flag)
17460  {
17461  byte* nativeLabel;
17462  int labelByteCount = 0;
17463  if (label != null)
17464  {
17465  labelByteCount = Encoding.UTF8.GetByteCount(label);
17466  if (labelByteCount > Util.StackAllocationSizeLimit)
17467  {
17468  nativeLabel = Util.Allocate(labelByteCount + 1);
17469  }
17470  else
17471  {
17472  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17473  nativeLabel = nativeLabelStackBytes;
17474  }
17475 
17476  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17477  nativeLabel[nativeLabelOffset] = 0;
17478  }
17479  else
17480  {
17481  nativeLabel = null;
17482  }
17483 
17484  byte* nativeFormat;
17485  int formatByteCount = 0;
17486  if (format != null)
17487  {
17488  formatByteCount = Encoding.UTF8.GetByteCount(format);
17489  if (formatByteCount > Util.StackAllocationSizeLimit)
17490  {
17491  nativeFormat = Util.Allocate(formatByteCount + 1);
17492  }
17493  else
17494  {
17495  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17496  nativeFormat = nativeFormatStackBytes;
17497  }
17498 
17499  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17500  nativeFormat[nativeFormatOffset] = 0;
17501  }
17502  else
17503  {
17504  nativeFormat = null;
17505  }
17506 
17507  fixed (float* nativeVRad = &vRad)
17508  {
17509  byte ret = ImGuiNative.igSliderAngle(nativeLabel, nativeVRad, vDegreesMin, vDegreesMax, nativeFormat, flag);
17510  if (labelByteCount > Util.StackAllocationSizeLimit)
17511  {
17512  Util.Free(nativeLabel);
17513  }
17514 
17515  if (formatByteCount > Util.StackAllocationSizeLimit)
17516  {
17517  Util.Free(nativeFormat);
17518  }
17519 
17520  return ret != 0;
17521  }
17522  }
17523 
17532  public static bool SliderFloat(string label, ref float v, float vMin, float vMax)
17533  {
17534  byte* nativeLabel;
17535  int labelByteCount = 0;
17536  if (label != null)
17537  {
17538  labelByteCount = Encoding.UTF8.GetByteCount(label);
17539  if (labelByteCount > Util.StackAllocationSizeLimit)
17540  {
17541  nativeLabel = Util.Allocate(labelByteCount + 1);
17542  }
17543  else
17544  {
17545  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17546  nativeLabel = nativeLabelStackBytes;
17547  }
17548 
17549  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17550  nativeLabel[nativeLabelOffset] = 0;
17551  }
17552  else
17553  {
17554  nativeLabel = null;
17555  }
17556 
17557  byte* nativeFormat;
17558  int formatByteCount = 0;
17559  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17560  if (formatByteCount > Util.StackAllocationSizeLimit)
17561  {
17562  nativeFormat = Util.Allocate(formatByteCount + 1);
17563  }
17564  else
17565  {
17566  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17567  nativeFormat = nativeFormatStackBytes;
17568  }
17569 
17570  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
17571  nativeFormat[nativeFormatOffset] = 0;
17572  ImGuiSliders flag = 0;
17573  fixed (float* nativeV = &v)
17574  {
17575  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17576  if (labelByteCount > Util.StackAllocationSizeLimit)
17577  {
17578  Util.Free(nativeLabel);
17579  }
17580 
17581  if (formatByteCount > Util.StackAllocationSizeLimit)
17582  {
17583  Util.Free(nativeFormat);
17584  }
17585 
17586  return ret != 0;
17587  }
17588  }
17589 
17599  public static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format)
17600  {
17601  byte* nativeLabel;
17602  int labelByteCount = 0;
17603  if (label != null)
17604  {
17605  labelByteCount = Encoding.UTF8.GetByteCount(label);
17606  if (labelByteCount > Util.StackAllocationSizeLimit)
17607  {
17608  nativeLabel = Util.Allocate(labelByteCount + 1);
17609  }
17610  else
17611  {
17612  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17613  nativeLabel = nativeLabelStackBytes;
17614  }
17615 
17616  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17617  nativeLabel[nativeLabelOffset] = 0;
17618  }
17619  else
17620  {
17621  nativeLabel = null;
17622  }
17623 
17624  byte* nativeFormat;
17625  int formatByteCount = 0;
17626  if (format != null)
17627  {
17628  formatByteCount = Encoding.UTF8.GetByteCount(format);
17629  if (formatByteCount > Util.StackAllocationSizeLimit)
17630  {
17631  nativeFormat = Util.Allocate(formatByteCount + 1);
17632  }
17633  else
17634  {
17635  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17636  nativeFormat = nativeFormatStackBytes;
17637  }
17638 
17639  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17640  nativeFormat[nativeFormatOffset] = 0;
17641  }
17642  else
17643  {
17644  nativeFormat = null;
17645  }
17646 
17647  ImGuiSliders flag = 0;
17648  fixed (float* nativeV = &v)
17649  {
17650  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17651  if (labelByteCount > Util.StackAllocationSizeLimit)
17652  {
17653  Util.Free(nativeLabel);
17654  }
17655 
17656  if (formatByteCount > Util.StackAllocationSizeLimit)
17657  {
17658  Util.Free(nativeFormat);
17659  }
17660 
17661  return ret != 0;
17662  }
17663  }
17664 
17675  public static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format, ImGuiSliders flag)
17676  {
17677  byte* nativeLabel;
17678  int labelByteCount = 0;
17679  if (label != null)
17680  {
17681  labelByteCount = Encoding.UTF8.GetByteCount(label);
17682  if (labelByteCount > Util.StackAllocationSizeLimit)
17683  {
17684  nativeLabel = Util.Allocate(labelByteCount + 1);
17685  }
17686  else
17687  {
17688  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17689  nativeLabel = nativeLabelStackBytes;
17690  }
17691 
17692  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17693  nativeLabel[nativeLabelOffset] = 0;
17694  }
17695  else
17696  {
17697  nativeLabel = null;
17698  }
17699 
17700  byte* nativeFormat;
17701  int formatByteCount = 0;
17702  if (format != null)
17703  {
17704  formatByteCount = Encoding.UTF8.GetByteCount(format);
17705  if (formatByteCount > Util.StackAllocationSizeLimit)
17706  {
17707  nativeFormat = Util.Allocate(formatByteCount + 1);
17708  }
17709  else
17710  {
17711  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17712  nativeFormat = nativeFormatStackBytes;
17713  }
17714 
17715  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17716  nativeFormat[nativeFormatOffset] = 0;
17717  }
17718  else
17719  {
17720  nativeFormat = null;
17721  }
17722 
17723  fixed (float* nativeV = &v)
17724  {
17725  byte ret = ImGuiNative.igSliderFloat(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17726  if (labelByteCount > Util.StackAllocationSizeLimit)
17727  {
17728  Util.Free(nativeLabel);
17729  }
17730 
17731  if (formatByteCount > Util.StackAllocationSizeLimit)
17732  {
17733  Util.Free(nativeFormat);
17734  }
17735 
17736  return ret != 0;
17737  }
17738  }
17739 
17748  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax)
17749  {
17750  byte* nativeLabel;
17751  int labelByteCount = 0;
17752  if (label != null)
17753  {
17754  labelByteCount = Encoding.UTF8.GetByteCount(label);
17755  if (labelByteCount > Util.StackAllocationSizeLimit)
17756  {
17757  nativeLabel = Util.Allocate(labelByteCount + 1);
17758  }
17759  else
17760  {
17761  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17762  nativeLabel = nativeLabelStackBytes;
17763  }
17764 
17765  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17766  nativeLabel[nativeLabelOffset] = 0;
17767  }
17768  else
17769  {
17770  nativeLabel = null;
17771  }
17772 
17773  byte* nativeFormat;
17774  int formatByteCount = 0;
17775  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17776  if (formatByteCount > Util.StackAllocationSizeLimit)
17777  {
17778  nativeFormat = Util.Allocate(formatByteCount + 1);
17779  }
17780  else
17781  {
17782  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17783  nativeFormat = nativeFormatStackBytes;
17784  }
17785 
17786  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
17787  nativeFormat[nativeFormatOffset] = 0;
17788  ImGuiSliders flag = 0;
17789  fixed (Vector2F* nativeV = &v)
17790  {
17791  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17792  if (labelByteCount > Util.StackAllocationSizeLimit)
17793  {
17794  Util.Free(nativeLabel);
17795  }
17796 
17797  if (formatByteCount > Util.StackAllocationSizeLimit)
17798  {
17799  Util.Free(nativeFormat);
17800  }
17801 
17802  return ret != 0;
17803  }
17804  }
17805 
17815  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format)
17816  {
17817  byte* nativeLabel;
17818  int labelByteCount = 0;
17819  if (label != null)
17820  {
17821  labelByteCount = Encoding.UTF8.GetByteCount(label);
17822  if (labelByteCount > Util.StackAllocationSizeLimit)
17823  {
17824  nativeLabel = Util.Allocate(labelByteCount + 1);
17825  }
17826  else
17827  {
17828  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17829  nativeLabel = nativeLabelStackBytes;
17830  }
17831 
17832  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17833  nativeLabel[nativeLabelOffset] = 0;
17834  }
17835  else
17836  {
17837  nativeLabel = null;
17838  }
17839 
17840  byte* nativeFormat;
17841  int formatByteCount = 0;
17842  if (format != null)
17843  {
17844  formatByteCount = Encoding.UTF8.GetByteCount(format);
17845  if (formatByteCount > Util.StackAllocationSizeLimit)
17846  {
17847  nativeFormat = Util.Allocate(formatByteCount + 1);
17848  }
17849  else
17850  {
17851  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17852  nativeFormat = nativeFormatStackBytes;
17853  }
17854 
17855  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17856  nativeFormat[nativeFormatOffset] = 0;
17857  }
17858  else
17859  {
17860  nativeFormat = null;
17861  }
17862 
17863  ImGuiSliders flag = 0;
17864  fixed (Vector2F* nativeV = &v)
17865  {
17866  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17867  if (labelByteCount > Util.StackAllocationSizeLimit)
17868  {
17869  Util.Free(nativeLabel);
17870  }
17871 
17872  if (formatByteCount > Util.StackAllocationSizeLimit)
17873  {
17874  Util.Free(nativeFormat);
17875  }
17876 
17877  return ret != 0;
17878  }
17879  }
17880 
17891  public static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format, ImGuiSliders flag)
17892  {
17893  byte* nativeLabel;
17894  int labelByteCount = 0;
17895  if (label != null)
17896  {
17897  labelByteCount = Encoding.UTF8.GetByteCount(label);
17898  if (labelByteCount > Util.StackAllocationSizeLimit)
17899  {
17900  nativeLabel = Util.Allocate(labelByteCount + 1);
17901  }
17902  else
17903  {
17904  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17905  nativeLabel = nativeLabelStackBytes;
17906  }
17907 
17908  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17909  nativeLabel[nativeLabelOffset] = 0;
17910  }
17911  else
17912  {
17913  nativeLabel = null;
17914  }
17915 
17916  byte* nativeFormat;
17917  int formatByteCount = 0;
17918  if (format != null)
17919  {
17920  formatByteCount = Encoding.UTF8.GetByteCount(format);
17921  if (formatByteCount > Util.StackAllocationSizeLimit)
17922  {
17923  nativeFormat = Util.Allocate(formatByteCount + 1);
17924  }
17925  else
17926  {
17927  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17928  nativeFormat = nativeFormatStackBytes;
17929  }
17930 
17931  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
17932  nativeFormat[nativeFormatOffset] = 0;
17933  }
17934  else
17935  {
17936  nativeFormat = null;
17937  }
17938 
17939  fixed (Vector2F* nativeV = &v)
17940  {
17941  byte ret = ImGuiNative.igSliderFloat2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
17942  if (labelByteCount > Util.StackAllocationSizeLimit)
17943  {
17944  Util.Free(nativeLabel);
17945  }
17946 
17947  if (formatByteCount > Util.StackAllocationSizeLimit)
17948  {
17949  Util.Free(nativeFormat);
17950  }
17951 
17952  return ret != 0;
17953  }
17954  }
17955 
17964  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax)
17965  {
17966  byte* nativeLabel;
17967  int labelByteCount = 0;
17968  if (label != null)
17969  {
17970  labelByteCount = Encoding.UTF8.GetByteCount(label);
17971  if (labelByteCount > Util.StackAllocationSizeLimit)
17972  {
17973  nativeLabel = Util.Allocate(labelByteCount + 1);
17974  }
17975  else
17976  {
17977  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
17978  nativeLabel = nativeLabelStackBytes;
17979  }
17980 
17981  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
17982  nativeLabel[nativeLabelOffset] = 0;
17983  }
17984  else
17985  {
17986  nativeLabel = null;
17987  }
17988 
17989  byte* nativeFormat;
17990  int formatByteCount = 0;
17991  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
17992  if (formatByteCount > Util.StackAllocationSizeLimit)
17993  {
17994  nativeFormat = Util.Allocate(formatByteCount + 1);
17995  }
17996  else
17997  {
17998  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
17999  nativeFormat = nativeFormatStackBytes;
18000  }
18001 
18002  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
18003  nativeFormat[nativeFormatOffset] = 0;
18004  ImGuiSliders flag = 0;
18005  fixed (Vector3F* nativeV = &v)
18006  {
18007  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18008  if (labelByteCount > Util.StackAllocationSizeLimit)
18009  {
18010  Util.Free(nativeLabel);
18011  }
18012 
18013  if (formatByteCount > Util.StackAllocationSizeLimit)
18014  {
18015  Util.Free(nativeFormat);
18016  }
18017 
18018  return ret != 0;
18019  }
18020  }
18021 
18031  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format)
18032  {
18033  byte* nativeLabel;
18034  int labelByteCount = 0;
18035  if (label != null)
18036  {
18037  labelByteCount = Encoding.UTF8.GetByteCount(label);
18038  if (labelByteCount > Util.StackAllocationSizeLimit)
18039  {
18040  nativeLabel = Util.Allocate(labelByteCount + 1);
18041  }
18042  else
18043  {
18044  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18045  nativeLabel = nativeLabelStackBytes;
18046  }
18047 
18048  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18049  nativeLabel[nativeLabelOffset] = 0;
18050  }
18051  else
18052  {
18053  nativeLabel = null;
18054  }
18055 
18056  byte* nativeFormat;
18057  int formatByteCount = 0;
18058  if (format != null)
18059  {
18060  formatByteCount = Encoding.UTF8.GetByteCount(format);
18061  if (formatByteCount > Util.StackAllocationSizeLimit)
18062  {
18063  nativeFormat = Util.Allocate(formatByteCount + 1);
18064  }
18065  else
18066  {
18067  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18068  nativeFormat = nativeFormatStackBytes;
18069  }
18070 
18071  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18072  nativeFormat[nativeFormatOffset] = 0;
18073  }
18074  else
18075  {
18076  nativeFormat = null;
18077  }
18078 
18079  ImGuiSliders flag = 0;
18080  fixed (Vector3F* nativeV = &v)
18081  {
18082  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18083  if (labelByteCount > Util.StackAllocationSizeLimit)
18084  {
18085  Util.Free(nativeLabel);
18086  }
18087 
18088  if (formatByteCount > Util.StackAllocationSizeLimit)
18089  {
18090  Util.Free(nativeFormat);
18091  }
18092 
18093  return ret != 0;
18094  }
18095  }
18096 
18107  public static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format, ImGuiSliders flag)
18108  {
18109  byte* nativeLabel;
18110  int labelByteCount = 0;
18111  if (label != null)
18112  {
18113  labelByteCount = Encoding.UTF8.GetByteCount(label);
18114  if (labelByteCount > Util.StackAllocationSizeLimit)
18115  {
18116  nativeLabel = Util.Allocate(labelByteCount + 1);
18117  }
18118  else
18119  {
18120  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18121  nativeLabel = nativeLabelStackBytes;
18122  }
18123 
18124  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18125  nativeLabel[nativeLabelOffset] = 0;
18126  }
18127  else
18128  {
18129  nativeLabel = null;
18130  }
18131 
18132  byte* nativeFormat;
18133  int formatByteCount = 0;
18134  if (format != null)
18135  {
18136  formatByteCount = Encoding.UTF8.GetByteCount(format);
18137  if (formatByteCount > Util.StackAllocationSizeLimit)
18138  {
18139  nativeFormat = Util.Allocate(formatByteCount + 1);
18140  }
18141  else
18142  {
18143  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18144  nativeFormat = nativeFormatStackBytes;
18145  }
18146 
18147  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18148  nativeFormat[nativeFormatOffset] = 0;
18149  }
18150  else
18151  {
18152  nativeFormat = null;
18153  }
18154 
18155  fixed (Vector3F* nativeV = &v)
18156  {
18157  byte ret = ImGuiNative.igSliderFloat3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18158  if (labelByteCount > Util.StackAllocationSizeLimit)
18159  {
18160  Util.Free(nativeLabel);
18161  }
18162 
18163  if (formatByteCount > Util.StackAllocationSizeLimit)
18164  {
18165  Util.Free(nativeFormat);
18166  }
18167 
18168  return ret != 0;
18169  }
18170  }
18171 
18180  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax)
18181  {
18182  byte* nativeLabel;
18183  int labelByteCount = 0;
18184  if (label != null)
18185  {
18186  labelByteCount = Encoding.UTF8.GetByteCount(label);
18187  if (labelByteCount > Util.StackAllocationSizeLimit)
18188  {
18189  nativeLabel = Util.Allocate(labelByteCount + 1);
18190  }
18191  else
18192  {
18193  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18194  nativeLabel = nativeLabelStackBytes;
18195  }
18196 
18197  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18198  nativeLabel[nativeLabelOffset] = 0;
18199  }
18200  else
18201  {
18202  nativeLabel = null;
18203  }
18204 
18205  byte* nativeFormat;
18206  int formatByteCount = 0;
18207  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
18208  if (formatByteCount > Util.StackAllocationSizeLimit)
18209  {
18210  nativeFormat = Util.Allocate(formatByteCount + 1);
18211  }
18212  else
18213  {
18214  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18215  nativeFormat = nativeFormatStackBytes;
18216  }
18217 
18218  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
18219  nativeFormat[nativeFormatOffset] = 0;
18220  ImGuiSliders flag = 0;
18221  fixed (Vector4F* nativeV = &v)
18222  {
18223  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18224  if (labelByteCount > Util.StackAllocationSizeLimit)
18225  {
18226  Util.Free(nativeLabel);
18227  }
18228 
18229  if (formatByteCount > Util.StackAllocationSizeLimit)
18230  {
18231  Util.Free(nativeFormat);
18232  }
18233 
18234  return ret != 0;
18235  }
18236  }
18237 
18247  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format)
18248  {
18249  byte* nativeLabel;
18250  int labelByteCount = 0;
18251  if (label != null)
18252  {
18253  labelByteCount = Encoding.UTF8.GetByteCount(label);
18254  if (labelByteCount > Util.StackAllocationSizeLimit)
18255  {
18256  nativeLabel = Util.Allocate(labelByteCount + 1);
18257  }
18258  else
18259  {
18260  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18261  nativeLabel = nativeLabelStackBytes;
18262  }
18263 
18264  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18265  nativeLabel[nativeLabelOffset] = 0;
18266  }
18267  else
18268  {
18269  nativeLabel = null;
18270  }
18271 
18272  byte* nativeFormat;
18273  int formatByteCount = 0;
18274  if (format != null)
18275  {
18276  formatByteCount = Encoding.UTF8.GetByteCount(format);
18277  if (formatByteCount > Util.StackAllocationSizeLimit)
18278  {
18279  nativeFormat = Util.Allocate(formatByteCount + 1);
18280  }
18281  else
18282  {
18283  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18284  nativeFormat = nativeFormatStackBytes;
18285  }
18286 
18287  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18288  nativeFormat[nativeFormatOffset] = 0;
18289  }
18290  else
18291  {
18292  nativeFormat = null;
18293  }
18294 
18295  ImGuiSliders flag = 0;
18296  fixed (Vector4F* nativeV = &v)
18297  {
18298  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18299  if (labelByteCount > Util.StackAllocationSizeLimit)
18300  {
18301  Util.Free(nativeLabel);
18302  }
18303 
18304  if (formatByteCount > Util.StackAllocationSizeLimit)
18305  {
18306  Util.Free(nativeFormat);
18307  }
18308 
18309  return ret != 0;
18310  }
18311  }
18312 
18323  public static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format, ImGuiSliders flag)
18324  {
18325  byte* nativeLabel;
18326  int labelByteCount = 0;
18327  if (label != null)
18328  {
18329  labelByteCount = Encoding.UTF8.GetByteCount(label);
18330  if (labelByteCount > Util.StackAllocationSizeLimit)
18331  {
18332  nativeLabel = Util.Allocate(labelByteCount + 1);
18333  }
18334  else
18335  {
18336  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18337  nativeLabel = nativeLabelStackBytes;
18338  }
18339 
18340  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18341  nativeLabel[nativeLabelOffset] = 0;
18342  }
18343  else
18344  {
18345  nativeLabel = null;
18346  }
18347 
18348  byte* nativeFormat;
18349  int formatByteCount = 0;
18350  if (format != null)
18351  {
18352  formatByteCount = Encoding.UTF8.GetByteCount(format);
18353  if (formatByteCount > Util.StackAllocationSizeLimit)
18354  {
18355  nativeFormat = Util.Allocate(formatByteCount + 1);
18356  }
18357  else
18358  {
18359  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18360  nativeFormat = nativeFormatStackBytes;
18361  }
18362 
18363  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18364  nativeFormat[nativeFormatOffset] = 0;
18365  }
18366  else
18367  {
18368  nativeFormat = null;
18369  }
18370 
18371  fixed (Vector4F* nativeV = &v)
18372  {
18373  byte ret = ImGuiNative.igSliderFloat4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18374  if (labelByteCount > Util.StackAllocationSizeLimit)
18375  {
18376  Util.Free(nativeLabel);
18377  }
18378 
18379  if (formatByteCount > Util.StackAllocationSizeLimit)
18380  {
18381  Util.Free(nativeFormat);
18382  }
18383 
18384  return ret != 0;
18385  }
18386  }
18387 
18396  public static bool SliderInt(string label, ref int v, int vMin, int vMax)
18397  {
18398  byte* nativeLabel;
18399  int labelByteCount = 0;
18400  if (label != null)
18401  {
18402  labelByteCount = Encoding.UTF8.GetByteCount(label);
18403  if (labelByteCount > Util.StackAllocationSizeLimit)
18404  {
18405  nativeLabel = Util.Allocate(labelByteCount + 1);
18406  }
18407  else
18408  {
18409  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18410  nativeLabel = nativeLabelStackBytes;
18411  }
18412 
18413  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18414  nativeLabel[nativeLabelOffset] = 0;
18415  }
18416  else
18417  {
18418  nativeLabel = null;
18419  }
18420 
18421  byte* nativeFormat;
18422  int formatByteCount = 0;
18423  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18424  if (formatByteCount > Util.StackAllocationSizeLimit)
18425  {
18426  nativeFormat = Util.Allocate(formatByteCount + 1);
18427  }
18428  else
18429  {
18430  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18431  nativeFormat = nativeFormatStackBytes;
18432  }
18433 
18434  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18435  nativeFormat[nativeFormatOffset] = 0;
18436  ImGuiSliders flag = 0;
18437  fixed (int* nativeV = &v)
18438  {
18439  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18440  if (labelByteCount > Util.StackAllocationSizeLimit)
18441  {
18442  Util.Free(nativeLabel);
18443  }
18444 
18445  if (formatByteCount > Util.StackAllocationSizeLimit)
18446  {
18447  Util.Free(nativeFormat);
18448  }
18449 
18450  return ret != 0;
18451  }
18452  }
18453 
18463  public static bool SliderInt(string label, ref int v, int vMin, int vMax, string format)
18464  {
18465  byte* nativeLabel;
18466  int labelByteCount = 0;
18467  if (label != null)
18468  {
18469  labelByteCount = Encoding.UTF8.GetByteCount(label);
18470  if (labelByteCount > Util.StackAllocationSizeLimit)
18471  {
18472  nativeLabel = Util.Allocate(labelByteCount + 1);
18473  }
18474  else
18475  {
18476  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18477  nativeLabel = nativeLabelStackBytes;
18478  }
18479 
18480  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18481  nativeLabel[nativeLabelOffset] = 0;
18482  }
18483  else
18484  {
18485  nativeLabel = null;
18486  }
18487 
18488  byte* nativeFormat;
18489  int formatByteCount = 0;
18490  if (format != null)
18491  {
18492  formatByteCount = Encoding.UTF8.GetByteCount(format);
18493  if (formatByteCount > Util.StackAllocationSizeLimit)
18494  {
18495  nativeFormat = Util.Allocate(formatByteCount + 1);
18496  }
18497  else
18498  {
18499  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18500  nativeFormat = nativeFormatStackBytes;
18501  }
18502 
18503  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18504  nativeFormat[nativeFormatOffset] = 0;
18505  }
18506  else
18507  {
18508  nativeFormat = null;
18509  }
18510 
18511  ImGuiSliders flag = 0;
18512  fixed (int* nativeV = &v)
18513  {
18514  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18515  if (labelByteCount > Util.StackAllocationSizeLimit)
18516  {
18517  Util.Free(nativeLabel);
18518  }
18519 
18520  if (formatByteCount > Util.StackAllocationSizeLimit)
18521  {
18522  Util.Free(nativeFormat);
18523  }
18524 
18525  return ret != 0;
18526  }
18527  }
18528 
18539  public static bool SliderInt(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
18540  {
18541  byte* nativeLabel;
18542  int labelByteCount = 0;
18543  if (label != null)
18544  {
18545  labelByteCount = Encoding.UTF8.GetByteCount(label);
18546  if (labelByteCount > Util.StackAllocationSizeLimit)
18547  {
18548  nativeLabel = Util.Allocate(labelByteCount + 1);
18549  }
18550  else
18551  {
18552  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18553  nativeLabel = nativeLabelStackBytes;
18554  }
18555 
18556  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18557  nativeLabel[nativeLabelOffset] = 0;
18558  }
18559  else
18560  {
18561  nativeLabel = null;
18562  }
18563 
18564  byte* nativeFormat;
18565  int formatByteCount = 0;
18566  if (format != null)
18567  {
18568  formatByteCount = Encoding.UTF8.GetByteCount(format);
18569  if (formatByteCount > Util.StackAllocationSizeLimit)
18570  {
18571  nativeFormat = Util.Allocate(formatByteCount + 1);
18572  }
18573  else
18574  {
18575  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18576  nativeFormat = nativeFormatStackBytes;
18577  }
18578 
18579  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18580  nativeFormat[nativeFormatOffset] = 0;
18581  }
18582  else
18583  {
18584  nativeFormat = null;
18585  }
18586 
18587  fixed (int* nativeV = &v)
18588  {
18589  byte ret = ImGuiNative.igSliderInt(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18590  if (labelByteCount > Util.StackAllocationSizeLimit)
18591  {
18592  Util.Free(nativeLabel);
18593  }
18594 
18595  if (formatByteCount > Util.StackAllocationSizeLimit)
18596  {
18597  Util.Free(nativeFormat);
18598  }
18599 
18600  return ret != 0;
18601  }
18602  }
18603 
18612  public static bool SliderInt2(string label, ref int v, int vMin, int vMax)
18613  {
18614  byte* nativeLabel;
18615  int labelByteCount = 0;
18616  if (label != null)
18617  {
18618  labelByteCount = Encoding.UTF8.GetByteCount(label);
18619  if (labelByteCount > Util.StackAllocationSizeLimit)
18620  {
18621  nativeLabel = Util.Allocate(labelByteCount + 1);
18622  }
18623  else
18624  {
18625  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18626  nativeLabel = nativeLabelStackBytes;
18627  }
18628 
18629  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18630  nativeLabel[nativeLabelOffset] = 0;
18631  }
18632  else
18633  {
18634  nativeLabel = null;
18635  }
18636 
18637  byte* nativeFormat;
18638  int formatByteCount = 0;
18639  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18640  if (formatByteCount > Util.StackAllocationSizeLimit)
18641  {
18642  nativeFormat = Util.Allocate(formatByteCount + 1);
18643  }
18644  else
18645  {
18646  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18647  nativeFormat = nativeFormatStackBytes;
18648  }
18649 
18650  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18651  nativeFormat[nativeFormatOffset] = 0;
18652  ImGuiSliders flag = 0;
18653  fixed (int* nativeV = &v)
18654  {
18655  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18656  if (labelByteCount > Util.StackAllocationSizeLimit)
18657  {
18658  Util.Free(nativeLabel);
18659  }
18660 
18661  if (formatByteCount > Util.StackAllocationSizeLimit)
18662  {
18663  Util.Free(nativeFormat);
18664  }
18665 
18666  return ret != 0;
18667  }
18668  }
18669 
18679  public static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format)
18680  {
18681  byte* nativeLabel;
18682  int labelByteCount = 0;
18683  if (label != null)
18684  {
18685  labelByteCount = Encoding.UTF8.GetByteCount(label);
18686  if (labelByteCount > Util.StackAllocationSizeLimit)
18687  {
18688  nativeLabel = Util.Allocate(labelByteCount + 1);
18689  }
18690  else
18691  {
18692  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18693  nativeLabel = nativeLabelStackBytes;
18694  }
18695 
18696  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18697  nativeLabel[nativeLabelOffset] = 0;
18698  }
18699  else
18700  {
18701  nativeLabel = null;
18702  }
18703 
18704  byte* nativeFormat;
18705  int formatByteCount = 0;
18706  if (format != null)
18707  {
18708  formatByteCount = Encoding.UTF8.GetByteCount(format);
18709  if (formatByteCount > Util.StackAllocationSizeLimit)
18710  {
18711  nativeFormat = Util.Allocate(formatByteCount + 1);
18712  }
18713  else
18714  {
18715  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18716  nativeFormat = nativeFormatStackBytes;
18717  }
18718 
18719  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18720  nativeFormat[nativeFormatOffset] = 0;
18721  }
18722  else
18723  {
18724  nativeFormat = null;
18725  }
18726 
18727  ImGuiSliders flag = 0;
18728  fixed (int* nativeV = &v)
18729  {
18730  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18731  if (labelByteCount > Util.StackAllocationSizeLimit)
18732  {
18733  Util.Free(nativeLabel);
18734  }
18735 
18736  if (formatByteCount > Util.StackAllocationSizeLimit)
18737  {
18738  Util.Free(nativeFormat);
18739  }
18740 
18741  return ret != 0;
18742  }
18743  }
18744 
18755  public static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
18756  {
18757  byte* nativeLabel;
18758  int labelByteCount = 0;
18759  if (label != null)
18760  {
18761  labelByteCount = Encoding.UTF8.GetByteCount(label);
18762  if (labelByteCount > Util.StackAllocationSizeLimit)
18763  {
18764  nativeLabel = Util.Allocate(labelByteCount + 1);
18765  }
18766  else
18767  {
18768  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18769  nativeLabel = nativeLabelStackBytes;
18770  }
18771 
18772  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18773  nativeLabel[nativeLabelOffset] = 0;
18774  }
18775  else
18776  {
18777  nativeLabel = null;
18778  }
18779 
18780  byte* nativeFormat;
18781  int formatByteCount = 0;
18782  if (format != null)
18783  {
18784  formatByteCount = Encoding.UTF8.GetByteCount(format);
18785  if (formatByteCount > Util.StackAllocationSizeLimit)
18786  {
18787  nativeFormat = Util.Allocate(formatByteCount + 1);
18788  }
18789  else
18790  {
18791  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18792  nativeFormat = nativeFormatStackBytes;
18793  }
18794 
18795  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18796  nativeFormat[nativeFormatOffset] = 0;
18797  }
18798  else
18799  {
18800  nativeFormat = null;
18801  }
18802 
18803  fixed (int* nativeV = &v)
18804  {
18805  byte ret = ImGuiNative.igSliderInt2(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18806  if (labelByteCount > Util.StackAllocationSizeLimit)
18807  {
18808  Util.Free(nativeLabel);
18809  }
18810 
18811  if (formatByteCount > Util.StackAllocationSizeLimit)
18812  {
18813  Util.Free(nativeFormat);
18814  }
18815 
18816  return ret != 0;
18817  }
18818  }
18819 
18828  public static bool SliderInt3(string label, ref int v, int vMin, int vMax)
18829  {
18830  byte* nativeLabel;
18831  int labelByteCount = 0;
18832  if (label != null)
18833  {
18834  labelByteCount = Encoding.UTF8.GetByteCount(label);
18835  if (labelByteCount > Util.StackAllocationSizeLimit)
18836  {
18837  nativeLabel = Util.Allocate(labelByteCount + 1);
18838  }
18839  else
18840  {
18841  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18842  nativeLabel = nativeLabelStackBytes;
18843  }
18844 
18845  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18846  nativeLabel[nativeLabelOffset] = 0;
18847  }
18848  else
18849  {
18850  nativeLabel = null;
18851  }
18852 
18853  byte* nativeFormat;
18854  int formatByteCount = 0;
18855  formatByteCount = Encoding.UTF8.GetByteCount("%d");
18856  if (formatByteCount > Util.StackAllocationSizeLimit)
18857  {
18858  nativeFormat = Util.Allocate(formatByteCount + 1);
18859  }
18860  else
18861  {
18862  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18863  nativeFormat = nativeFormatStackBytes;
18864  }
18865 
18866  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
18867  nativeFormat[nativeFormatOffset] = 0;
18868  ImGuiSliders flag = 0;
18869  fixed (int* nativeV = &v)
18870  {
18871  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18872  if (labelByteCount > Util.StackAllocationSizeLimit)
18873  {
18874  Util.Free(nativeLabel);
18875  }
18876 
18877  if (formatByteCount > Util.StackAllocationSizeLimit)
18878  {
18879  Util.Free(nativeFormat);
18880  }
18881 
18882  return ret != 0;
18883  }
18884  }
18885 
18895  public static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format)
18896  {
18897  byte* nativeLabel;
18898  int labelByteCount = 0;
18899  if (label != null)
18900  {
18901  labelByteCount = Encoding.UTF8.GetByteCount(label);
18902  if (labelByteCount > Util.StackAllocationSizeLimit)
18903  {
18904  nativeLabel = Util.Allocate(labelByteCount + 1);
18905  }
18906  else
18907  {
18908  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18909  nativeLabel = nativeLabelStackBytes;
18910  }
18911 
18912  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18913  nativeLabel[nativeLabelOffset] = 0;
18914  }
18915  else
18916  {
18917  nativeLabel = null;
18918  }
18919 
18920  byte* nativeFormat;
18921  int formatByteCount = 0;
18922  if (format != null)
18923  {
18924  formatByteCount = Encoding.UTF8.GetByteCount(format);
18925  if (formatByteCount > Util.StackAllocationSizeLimit)
18926  {
18927  nativeFormat = Util.Allocate(formatByteCount + 1);
18928  }
18929  else
18930  {
18931  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
18932  nativeFormat = nativeFormatStackBytes;
18933  }
18934 
18935  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
18936  nativeFormat[nativeFormatOffset] = 0;
18937  }
18938  else
18939  {
18940  nativeFormat = null;
18941  }
18942 
18943  ImGuiSliders flag = 0;
18944  fixed (int* nativeV = &v)
18945  {
18946  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
18947  if (labelByteCount > Util.StackAllocationSizeLimit)
18948  {
18949  Util.Free(nativeLabel);
18950  }
18951 
18952  if (formatByteCount > Util.StackAllocationSizeLimit)
18953  {
18954  Util.Free(nativeFormat);
18955  }
18956 
18957  return ret != 0;
18958  }
18959  }
18960 
18971  public static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
18972  {
18973  byte* nativeLabel;
18974  int labelByteCount = 0;
18975  if (label != null)
18976  {
18977  labelByteCount = Encoding.UTF8.GetByteCount(label);
18978  if (labelByteCount > Util.StackAllocationSizeLimit)
18979  {
18980  nativeLabel = Util.Allocate(labelByteCount + 1);
18981  }
18982  else
18983  {
18984  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
18985  nativeLabel = nativeLabelStackBytes;
18986  }
18987 
18988  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
18989  nativeLabel[nativeLabelOffset] = 0;
18990  }
18991  else
18992  {
18993  nativeLabel = null;
18994  }
18995 
18996  byte* nativeFormat;
18997  int formatByteCount = 0;
18998  if (format != null)
18999  {
19000  formatByteCount = Encoding.UTF8.GetByteCount(format);
19001  if (formatByteCount > Util.StackAllocationSizeLimit)
19002  {
19003  nativeFormat = Util.Allocate(formatByteCount + 1);
19004  }
19005  else
19006  {
19007  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19008  nativeFormat = nativeFormatStackBytes;
19009  }
19010 
19011  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19012  nativeFormat[nativeFormatOffset] = 0;
19013  }
19014  else
19015  {
19016  nativeFormat = null;
19017  }
19018 
19019  fixed (int* nativeV = &v)
19020  {
19021  byte ret = ImGuiNative.igSliderInt3(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
19022  if (labelByteCount > Util.StackAllocationSizeLimit)
19023  {
19024  Util.Free(nativeLabel);
19025  }
19026 
19027  if (formatByteCount > Util.StackAllocationSizeLimit)
19028  {
19029  Util.Free(nativeFormat);
19030  }
19031 
19032  return ret != 0;
19033  }
19034  }
19035 
19044  public static bool SliderInt4(string label, ref int v, int vMin, int vMax)
19045  {
19046  byte* nativeLabel;
19047  int labelByteCount = 0;
19048  if (label != null)
19049  {
19050  labelByteCount = Encoding.UTF8.GetByteCount(label);
19051  if (labelByteCount > Util.StackAllocationSizeLimit)
19052  {
19053  nativeLabel = Util.Allocate(labelByteCount + 1);
19054  }
19055  else
19056  {
19057  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19058  nativeLabel = nativeLabelStackBytes;
19059  }
19060 
19061  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19062  nativeLabel[nativeLabelOffset] = 0;
19063  }
19064  else
19065  {
19066  nativeLabel = null;
19067  }
19068 
19069  byte* nativeFormat;
19070  int formatByteCount = 0;
19071  formatByteCount = Encoding.UTF8.GetByteCount("%d");
19072  if (formatByteCount > Util.StackAllocationSizeLimit)
19073  {
19074  nativeFormat = Util.Allocate(formatByteCount + 1);
19075  }
19076  else
19077  {
19078  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19079  nativeFormat = nativeFormatStackBytes;
19080  }
19081 
19082  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
19083  nativeFormat[nativeFormatOffset] = 0;
19084  ImGuiSliders flag = 0;
19085  fixed (int* nativeV = &v)
19086  {
19087  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
19088  if (labelByteCount > Util.StackAllocationSizeLimit)
19089  {
19090  Util.Free(nativeLabel);
19091  }
19092 
19093  if (formatByteCount > Util.StackAllocationSizeLimit)
19094  {
19095  Util.Free(nativeFormat);
19096  }
19097 
19098  return ret != 0;
19099  }
19100  }
19101 
19111  public static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format)
19112  {
19113  byte* nativeLabel;
19114  int labelByteCount = 0;
19115  if (label != null)
19116  {
19117  labelByteCount = Encoding.UTF8.GetByteCount(label);
19118  if (labelByteCount > Util.StackAllocationSizeLimit)
19119  {
19120  nativeLabel = Util.Allocate(labelByteCount + 1);
19121  }
19122  else
19123  {
19124  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19125  nativeLabel = nativeLabelStackBytes;
19126  }
19127 
19128  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19129  nativeLabel[nativeLabelOffset] = 0;
19130  }
19131  else
19132  {
19133  nativeLabel = null;
19134  }
19135 
19136  byte* nativeFormat;
19137  int formatByteCount = 0;
19138  if (format != null)
19139  {
19140  formatByteCount = Encoding.UTF8.GetByteCount(format);
19141  if (formatByteCount > Util.StackAllocationSizeLimit)
19142  {
19143  nativeFormat = Util.Allocate(formatByteCount + 1);
19144  }
19145  else
19146  {
19147  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19148  nativeFormat = nativeFormatStackBytes;
19149  }
19150 
19151  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19152  nativeFormat[nativeFormatOffset] = 0;
19153  }
19154  else
19155  {
19156  nativeFormat = null;
19157  }
19158 
19159  ImGuiSliders flag = 0;
19160  fixed (int* nativeV = &v)
19161  {
19162  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
19163  if (labelByteCount > Util.StackAllocationSizeLimit)
19164  {
19165  Util.Free(nativeLabel);
19166  }
19167 
19168  if (formatByteCount > Util.StackAllocationSizeLimit)
19169  {
19170  Util.Free(nativeFormat);
19171  }
19172 
19173  return ret != 0;
19174  }
19175  }
19176 
19187  public static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
19188  {
19189  byte* nativeLabel;
19190  int labelByteCount = 0;
19191  if (label != null)
19192  {
19193  labelByteCount = Encoding.UTF8.GetByteCount(label);
19194  if (labelByteCount > Util.StackAllocationSizeLimit)
19195  {
19196  nativeLabel = Util.Allocate(labelByteCount + 1);
19197  }
19198  else
19199  {
19200  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19201  nativeLabel = nativeLabelStackBytes;
19202  }
19203 
19204  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19205  nativeLabel[nativeLabelOffset] = 0;
19206  }
19207  else
19208  {
19209  nativeLabel = null;
19210  }
19211 
19212  byte* nativeFormat;
19213  int formatByteCount = 0;
19214  if (format != null)
19215  {
19216  formatByteCount = Encoding.UTF8.GetByteCount(format);
19217  if (formatByteCount > Util.StackAllocationSizeLimit)
19218  {
19219  nativeFormat = Util.Allocate(formatByteCount + 1);
19220  }
19221  else
19222  {
19223  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19224  nativeFormat = nativeFormatStackBytes;
19225  }
19226 
19227  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19228  nativeFormat[nativeFormatOffset] = 0;
19229  }
19230  else
19231  {
19232  nativeFormat = null;
19233  }
19234 
19235  fixed (int* nativeV = &v)
19236  {
19237  byte ret = ImGuiNative.igSliderInt4(nativeLabel, nativeV, vMin, vMax, nativeFormat, flag);
19238  if (labelByteCount > Util.StackAllocationSizeLimit)
19239  {
19240  Util.Free(nativeLabel);
19241  }
19242 
19243  if (formatByteCount > Util.StackAllocationSizeLimit)
19244  {
19245  Util.Free(nativeFormat);
19246  }
19247 
19248  return ret != 0;
19249  }
19250  }
19251 
19261  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
19262  {
19263  byte* nativeLabel;
19264  int labelByteCount = 0;
19265  if (label != null)
19266  {
19267  labelByteCount = Encoding.UTF8.GetByteCount(label);
19268  if (labelByteCount > Util.StackAllocationSizeLimit)
19269  {
19270  nativeLabel = Util.Allocate(labelByteCount + 1);
19271  }
19272  else
19273  {
19274  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19275  nativeLabel = nativeLabelStackBytes;
19276  }
19277 
19278  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19279  nativeLabel[nativeLabelOffset] = 0;
19280  }
19281  else
19282  {
19283  nativeLabel = null;
19284  }
19285 
19286  void* nativePData = pData.ToPointer();
19287  void* nativePMin = pMin.ToPointer();
19288  void* nativePMax = pMax.ToPointer();
19289  byte* nativeFormat = null;
19290  ImGuiSliders flag = 0;
19291  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
19292  if (labelByteCount > Util.StackAllocationSizeLimit)
19293  {
19294  Util.Free(nativeLabel);
19295  }
19296 
19297  return ret != 0;
19298  }
19299 
19310  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
19311  {
19312  byte* nativeLabel;
19313  int labelByteCount = 0;
19314  if (label != null)
19315  {
19316  labelByteCount = Encoding.UTF8.GetByteCount(label);
19317  if (labelByteCount > Util.StackAllocationSizeLimit)
19318  {
19319  nativeLabel = Util.Allocate(labelByteCount + 1);
19320  }
19321  else
19322  {
19323  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19324  nativeLabel = nativeLabelStackBytes;
19325  }
19326 
19327  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19328  nativeLabel[nativeLabelOffset] = 0;
19329  }
19330  else
19331  {
19332  nativeLabel = null;
19333  }
19334 
19335  void* nativePData = pData.ToPointer();
19336  void* nativePMin = pMin.ToPointer();
19337  void* nativePMax = pMax.ToPointer();
19338  byte* nativeFormat;
19339  int formatByteCount = 0;
19340  if (format != null)
19341  {
19342  formatByteCount = Encoding.UTF8.GetByteCount(format);
19343  if (formatByteCount > Util.StackAllocationSizeLimit)
19344  {
19345  nativeFormat = Util.Allocate(formatByteCount + 1);
19346  }
19347  else
19348  {
19349  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19350  nativeFormat = nativeFormatStackBytes;
19351  }
19352 
19353  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19354  nativeFormat[nativeFormatOffset] = 0;
19355  }
19356  else
19357  {
19358  nativeFormat = null;
19359  }
19360 
19361  ImGuiSliders flag = 0;
19362  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
19363  if (labelByteCount > Util.StackAllocationSizeLimit)
19364  {
19365  Util.Free(nativeLabel);
19366  }
19367 
19368  if (formatByteCount > Util.StackAllocationSizeLimit)
19369  {
19370  Util.Free(nativeFormat);
19371  }
19372 
19373  return ret != 0;
19374  }
19375 
19387  public static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
19388  {
19389  byte* nativeLabel;
19390  int labelByteCount = 0;
19391  if (label != null)
19392  {
19393  labelByteCount = Encoding.UTF8.GetByteCount(label);
19394  if (labelByteCount > Util.StackAllocationSizeLimit)
19395  {
19396  nativeLabel = Util.Allocate(labelByteCount + 1);
19397  }
19398  else
19399  {
19400  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19401  nativeLabel = nativeLabelStackBytes;
19402  }
19403 
19404  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19405  nativeLabel[nativeLabelOffset] = 0;
19406  }
19407  else
19408  {
19409  nativeLabel = null;
19410  }
19411 
19412  void* nativePData = pData.ToPointer();
19413  void* nativePMin = pMin.ToPointer();
19414  void* nativePMax = pMax.ToPointer();
19415  byte* nativeFormat;
19416  int formatByteCount = 0;
19417  if (format != null)
19418  {
19419  formatByteCount = Encoding.UTF8.GetByteCount(format);
19420  if (formatByteCount > Util.StackAllocationSizeLimit)
19421  {
19422  nativeFormat = Util.Allocate(formatByteCount + 1);
19423  }
19424  else
19425  {
19426  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19427  nativeFormat = nativeFormatStackBytes;
19428  }
19429 
19430  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19431  nativeFormat[nativeFormatOffset] = 0;
19432  }
19433  else
19434  {
19435  nativeFormat = null;
19436  }
19437 
19438  byte ret = ImGuiNative.igSliderScalar(nativeLabel, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
19439  if (labelByteCount > Util.StackAllocationSizeLimit)
19440  {
19441  Util.Free(nativeLabel);
19442  }
19443 
19444  if (formatByteCount > Util.StackAllocationSizeLimit)
19445  {
19446  Util.Free(nativeFormat);
19447  }
19448 
19449  return ret != 0;
19450  }
19451 
19462  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax)
19463  {
19464  byte* nativeLabel;
19465  int labelByteCount = 0;
19466  if (label != null)
19467  {
19468  labelByteCount = Encoding.UTF8.GetByteCount(label);
19469  if (labelByteCount > Util.StackAllocationSizeLimit)
19470  {
19471  nativeLabel = Util.Allocate(labelByteCount + 1);
19472  }
19473  else
19474  {
19475  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19476  nativeLabel = nativeLabelStackBytes;
19477  }
19478 
19479  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19480  nativeLabel[nativeLabelOffset] = 0;
19481  }
19482  else
19483  {
19484  nativeLabel = null;
19485  }
19486 
19487  void* nativePData = pData.ToPointer();
19488  void* nativePMin = pMin.ToPointer();
19489  void* nativePMax = pMax.ToPointer();
19490  byte* nativeFormat = null;
19491  ImGuiSliders flag = 0;
19492  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flag);
19493  if (labelByteCount > Util.StackAllocationSizeLimit)
19494  {
19495  Util.Free(nativeLabel);
19496  }
19497 
19498  return ret != 0;
19499  }
19500 
19512  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format)
19513  {
19514  byte* nativeLabel;
19515  int labelByteCount = 0;
19516  if (label != null)
19517  {
19518  labelByteCount = Encoding.UTF8.GetByteCount(label);
19519  if (labelByteCount > Util.StackAllocationSizeLimit)
19520  {
19521  nativeLabel = Util.Allocate(labelByteCount + 1);
19522  }
19523  else
19524  {
19525  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19526  nativeLabel = nativeLabelStackBytes;
19527  }
19528 
19529  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19530  nativeLabel[nativeLabelOffset] = 0;
19531  }
19532  else
19533  {
19534  nativeLabel = null;
19535  }
19536 
19537  void* nativePData = pData.ToPointer();
19538  void* nativePMin = pMin.ToPointer();
19539  void* nativePMax = pMax.ToPointer();
19540  byte* nativeFormat;
19541  int formatByteCount = 0;
19542  if (format != null)
19543  {
19544  formatByteCount = Encoding.UTF8.GetByteCount(format);
19545  if (formatByteCount > Util.StackAllocationSizeLimit)
19546  {
19547  nativeFormat = Util.Allocate(formatByteCount + 1);
19548  }
19549  else
19550  {
19551  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19552  nativeFormat = nativeFormatStackBytes;
19553  }
19554 
19555  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19556  nativeFormat[nativeFormatOffset] = 0;
19557  }
19558  else
19559  {
19560  nativeFormat = null;
19561  }
19562 
19563  ImGuiSliders flag = 0;
19564  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flag);
19565  if (labelByteCount > Util.StackAllocationSizeLimit)
19566  {
19567  Util.Free(nativeLabel);
19568  }
19569 
19570  if (formatByteCount > Util.StackAllocationSizeLimit)
19571  {
19572  Util.Free(nativeFormat);
19573  }
19574 
19575  return ret != 0;
19576  }
19577 
19590  public static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
19591  {
19592  byte* nativeLabel;
19593  int labelByteCount = 0;
19594  if (label != null)
19595  {
19596  labelByteCount = Encoding.UTF8.GetByteCount(label);
19597  if (labelByteCount > Util.StackAllocationSizeLimit)
19598  {
19599  nativeLabel = Util.Allocate(labelByteCount + 1);
19600  }
19601  else
19602  {
19603  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19604  nativeLabel = nativeLabelStackBytes;
19605  }
19606 
19607  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19608  nativeLabel[nativeLabelOffset] = 0;
19609  }
19610  else
19611  {
19612  nativeLabel = null;
19613  }
19614 
19615  void* nativePData = pData.ToPointer();
19616  void* nativePMin = pMin.ToPointer();
19617  void* nativePMax = pMax.ToPointer();
19618  byte* nativeFormat;
19619  int formatByteCount = 0;
19620  if (format != null)
19621  {
19622  formatByteCount = Encoding.UTF8.GetByteCount(format);
19623  if (formatByteCount > Util.StackAllocationSizeLimit)
19624  {
19625  nativeFormat = Util.Allocate(formatByteCount + 1);
19626  }
19627  else
19628  {
19629  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
19630  nativeFormat = nativeFormatStackBytes;
19631  }
19632 
19633  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
19634  nativeFormat[nativeFormatOffset] = 0;
19635  }
19636  else
19637  {
19638  nativeFormat = null;
19639  }
19640 
19641  byte ret = ImGuiNative.igSliderScalarN(nativeLabel, dataType, nativePData, components, nativePMin, nativePMax, nativeFormat, flag);
19642  if (labelByteCount > Util.StackAllocationSizeLimit)
19643  {
19644  Util.Free(nativeLabel);
19645  }
19646 
19647  if (formatByteCount > Util.StackAllocationSizeLimit)
19648  {
19649  Util.Free(nativeFormat);
19650  }
19651 
19652  return ret != 0;
19653  }
19654 
19660  public static bool SmallButton(string label)
19661  {
19662  byte* nativeLabel;
19663  int labelByteCount = 0;
19664  if (label != null)
19665  {
19666  labelByteCount = Encoding.UTF8.GetByteCount(label);
19667  if (labelByteCount > Util.StackAllocationSizeLimit)
19668  {
19669  nativeLabel = Util.Allocate(labelByteCount + 1);
19670  }
19671  else
19672  {
19673  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19674  nativeLabel = nativeLabelStackBytes;
19675  }
19676 
19677  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19678  nativeLabel[nativeLabelOffset] = 0;
19679  }
19680  else
19681  {
19682  nativeLabel = null;
19683  }
19684 
19685  byte ret = ImGuiNative.igSmallButton(nativeLabel);
19686  if (labelByteCount > Util.StackAllocationSizeLimit)
19687  {
19688  Util.Free(nativeLabel);
19689  }
19690 
19691  return ret != 0;
19692  }
19693 
19697  public static void Spacing()
19698  {
19700  }
19701 
19705  public static void StyleColorsClassic()
19706  {
19707  ImGuiStyle* dst = null;
19709  }
19710 
19715  public static void StyleColorsClassic(ImGuiStylePtr dst)
19716  {
19717  ImGuiStyle* nativeDst = dst.NativePtr;
19718  ImGuiNative.igStyleColorsClassic(nativeDst);
19719  }
19720 
19724  public static void StyleColorsDark()
19725  {
19726  ImGuiStyle* dst = null;
19728  }
19729 
19734  public static void StyleColorsDark(ImGuiStylePtr dst)
19735  {
19736  ImGuiStyle* nativeDst = dst.NativePtr;
19737  ImGuiNative.igStyleColorsDark(nativeDst);
19738  }
19739 
19743  public static void StyleColorsLight()
19744  {
19745  ImGuiStyle* dst = null;
19747  }
19748 
19753  public static void StyleColorsLight(ImGuiStylePtr dst)
19754  {
19755  ImGuiStyle* nativeDst = dst.NativePtr;
19756  ImGuiNative.igStyleColorsLight(nativeDst);
19757  }
19758 
19764  public static bool TabItemButton(string label)
19765  {
19766  byte* nativeLabel;
19767  int labelByteCount = 0;
19768  if (label != null)
19769  {
19770  labelByteCount = Encoding.UTF8.GetByteCount(label);
19771  if (labelByteCount > Util.StackAllocationSizeLimit)
19772  {
19773  nativeLabel = Util.Allocate(labelByteCount + 1);
19774  }
19775  else
19776  {
19777  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19778  nativeLabel = nativeLabelStackBytes;
19779  }
19780 
19781  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19782  nativeLabel[nativeLabelOffset] = 0;
19783  }
19784  else
19785  {
19786  nativeLabel = null;
19787  }
19788 
19789  ImGuiTabItems flag = 0;
19790  byte ret = ImGuiNative.igTabItemButton(nativeLabel, flag);
19791  if (labelByteCount > Util.StackAllocationSizeLimit)
19792  {
19793  Util.Free(nativeLabel);
19794  }
19795 
19796  return ret != 0;
19797  }
19798 
19805  public static bool TabItemButton(string label, ImGuiTabItems flag)
19806  {
19807  byte* nativeLabel;
19808  int labelByteCount = 0;
19809  if (label != null)
19810  {
19811  labelByteCount = Encoding.UTF8.GetByteCount(label);
19812  if (labelByteCount > Util.StackAllocationSizeLimit)
19813  {
19814  nativeLabel = Util.Allocate(labelByteCount + 1);
19815  }
19816  else
19817  {
19818  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19819  nativeLabel = nativeLabelStackBytes;
19820  }
19821 
19822  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19823  nativeLabel[nativeLabelOffset] = 0;
19824  }
19825  else
19826  {
19827  nativeLabel = null;
19828  }
19829 
19830  byte ret = ImGuiNative.igTabItemButton(nativeLabel, flag);
19831  if (labelByteCount > Util.StackAllocationSizeLimit)
19832  {
19833  Util.Free(nativeLabel);
19834  }
19835 
19836  return ret != 0;
19837  }
19838 
19843  public static int TableGetColumnCount()
19844  {
19845  int ret = ImGuiNative.igTableGetColumnCount();
19846  return ret;
19847  }
19848 
19854  {
19855  int columnN = -1;
19857  return ret;
19858  }
19859 
19865  public static ImGuiTableColumns TableGetColumnFlags(int columnN)
19866  {
19868  return ret;
19869  }
19870 
19875  public static int TableGetColumnIndex()
19876  {
19877  int ret = ImGuiNative.igTableGetColumnIndex();
19878  return ret;
19879  }
19880 
19885  public static string TableGetColumnName()
19886  {
19887  int columnN = -1;
19888  byte* ret = ImGuiNative.igTableGetColumnName_Int(columnN);
19889  return Util.StringFromPtr(ret);
19890  }
19891 
19897  public static string TableGetColumnName(int columnN)
19898  {
19899  byte* ret = ImGuiNative.igTableGetColumnName_Int(columnN);
19900  return Util.StringFromPtr(ret);
19901  }
19902 
19907  public static int TableGetRowIndex()
19908  {
19909  int ret = ImGuiNative.igTableGetRowIndex();
19910  return ret;
19911  }
19912 
19918  {
19920  return new ImGuiTableSortSpecsPtr(ret);
19921  }
19922 
19927  public static void TableHeader(string label)
19928  {
19929  byte* nativeLabel;
19930  int labelByteCount = 0;
19931  if (label != null)
19932  {
19933  labelByteCount = Encoding.UTF8.GetByteCount(label);
19934  if (labelByteCount > Util.StackAllocationSizeLimit)
19935  {
19936  nativeLabel = Util.Allocate(labelByteCount + 1);
19937  }
19938  else
19939  {
19940  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
19941  nativeLabel = nativeLabelStackBytes;
19942  }
19943 
19944  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
19945  nativeLabel[nativeLabelOffset] = 0;
19946  }
19947  else
19948  {
19949  nativeLabel = null;
19950  }
19951 
19952  ImGuiNative.igTableHeader(nativeLabel);
19953  if (labelByteCount > Util.StackAllocationSizeLimit)
19954  {
19955  Util.Free(nativeLabel);
19956  }
19957  }
19958 
19962  public static void TableHeadersRow()
19963  {
19965  }
19966 
19971  public static bool TableNextColumn()
19972  {
19973  byte ret = ImGuiNative.igTableNextColumn();
19974  return ret != 0;
19975  }
19976 
19980  public static void TableNextRow()
19981  {
19982  ImGuiTableRows rows = 0;
19983  float minRowHeight = 0.0f;
19984  ImGuiNative.igTableNextRow(rows, minRowHeight);
19985  }
19986 
19991  public static void TableNextRow(ImGuiTableRows rows)
19992  {
19993  float minRowHeight = 0.0f;
19994  ImGuiNative.igTableNextRow(rows, minRowHeight);
19995  }
19996 
20002  public static void TableNextRow(ImGuiTableRows rows, float minRowHeight)
20003  {
20004  ImGuiNative.igTableNextRow(rows, minRowHeight);
20005  }
20006 
20012  public static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
20013  {
20014  int columnN = -1;
20015  ImGuiNative.igTableSetBgColor(target, color, columnN);
20016  }
20017 
20024  public static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
20025  {
20026  ImGuiNative.igTableSetBgColor(target, color, columnN);
20027  }
20028 
20034  public static void TableSetColumnEnabled(int columnN, bool v)
20035  {
20036  byte nativeV = v ? (byte) 1 : (byte) 0;
20037  ImGuiNative.igTableSetColumnEnabled(columnN, nativeV);
20038  }
20039 
20045  public static bool TableSetColumnIndex(int columnN)
20046  {
20047  byte ret = ImGuiNative.igTableSetColumnIndex(columnN);
20048  return ret != 0;
20049  }
20050 
20055  public static void TableSetupColumn(string label)
20056  {
20057  byte* nativeLabel;
20058  int labelByteCount = 0;
20059  if (label != null)
20060  {
20061  labelByteCount = Encoding.UTF8.GetByteCount(label);
20062  if (labelByteCount > Util.StackAllocationSizeLimit)
20063  {
20064  nativeLabel = Util.Allocate(labelByteCount + 1);
20065  }
20066  else
20067  {
20068  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20069  nativeLabel = nativeLabelStackBytes;
20070  }
20071 
20072  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20073  nativeLabel[nativeLabelOffset] = 0;
20074  }
20075  else
20076  {
20077  nativeLabel = null;
20078  }
20079 
20080  ImGuiTableColumns flag = 0;
20081  float initWidthOrWeight = 0.0f;
20082  uint userId = 0;
20083  ImGuiNative.igTableSetupColumn(nativeLabel, flag, initWidthOrWeight, userId);
20084  if (labelByteCount > Util.StackAllocationSizeLimit)
20085  {
20086  Util.Free(nativeLabel);
20087  }
20088  }
20089 
20095  public static void TableSetupColumn(string label, ImGuiTableColumns flag)
20096  {
20097  byte* nativeLabel;
20098  int labelByteCount = 0;
20099  if (label != null)
20100  {
20101  labelByteCount = Encoding.UTF8.GetByteCount(label);
20102  if (labelByteCount > Util.StackAllocationSizeLimit)
20103  {
20104  nativeLabel = Util.Allocate(labelByteCount + 1);
20105  }
20106  else
20107  {
20108  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20109  nativeLabel = nativeLabelStackBytes;
20110  }
20111 
20112  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20113  nativeLabel[nativeLabelOffset] = 0;
20114  }
20115  else
20116  {
20117  nativeLabel = null;
20118  }
20119 
20120  float initWidthOrWeight = 0.0f;
20121  uint userId = 0;
20122  ImGuiNative.igTableSetupColumn(nativeLabel, flag, initWidthOrWeight, userId);
20123  if (labelByteCount > Util.StackAllocationSizeLimit)
20124  {
20125  Util.Free(nativeLabel);
20126  }
20127  }
20128 
20135  public static void TableSetupColumn(string label, ImGuiTableColumns flag, float initWidthOrWeight)
20136  {
20137  byte* nativeLabel;
20138  int labelByteCount = 0;
20139  if (label != null)
20140  {
20141  labelByteCount = Encoding.UTF8.GetByteCount(label);
20142  if (labelByteCount > Util.StackAllocationSizeLimit)
20143  {
20144  nativeLabel = Util.Allocate(labelByteCount + 1);
20145  }
20146  else
20147  {
20148  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20149  nativeLabel = nativeLabelStackBytes;
20150  }
20151 
20152  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20153  nativeLabel[nativeLabelOffset] = 0;
20154  }
20155  else
20156  {
20157  nativeLabel = null;
20158  }
20159 
20160  uint userId = 0;
20161  ImGuiNative.igTableSetupColumn(nativeLabel, flag, initWidthOrWeight, userId);
20162  if (labelByteCount > Util.StackAllocationSizeLimit)
20163  {
20164  Util.Free(nativeLabel);
20165  }
20166  }
20167 
20175  public static void TableSetupColumn(string label, ImGuiTableColumns flag, float initWidthOrWeight, uint userId)
20176  {
20177  byte* nativeLabel;
20178  int labelByteCount = 0;
20179  if (label != null)
20180  {
20181  labelByteCount = Encoding.UTF8.GetByteCount(label);
20182  if (labelByteCount > Util.StackAllocationSizeLimit)
20183  {
20184  nativeLabel = Util.Allocate(labelByteCount + 1);
20185  }
20186  else
20187  {
20188  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20189  nativeLabel = nativeLabelStackBytes;
20190  }
20191 
20192  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20193  nativeLabel[nativeLabelOffset] = 0;
20194  }
20195  else
20196  {
20197  nativeLabel = null;
20198  }
20199 
20200  ImGuiNative.igTableSetupColumn(nativeLabel, flag, initWidthOrWeight, userId);
20201  if (labelByteCount > Util.StackAllocationSizeLimit)
20202  {
20203  Util.Free(nativeLabel);
20204  }
20205  }
20206 
20212  public static void TableSetupScrollFreeze(int cols, int rows)
20213  {
20215  }
20216 
20221  public static void Text(string fmt)
20222  {
20223  byte* nativeFmt;
20224  int fmtByteCount = 0;
20225  if (fmt != null)
20226  {
20227  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20228  if (fmtByteCount > Util.StackAllocationSizeLimit)
20229  {
20230  nativeFmt = Util.Allocate(fmtByteCount + 1);
20231  }
20232  else
20233  {
20234  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20235  nativeFmt = nativeFmtStackBytes;
20236  }
20237 
20238  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20239  nativeFmt[nativeFmtOffset] = 0;
20240  }
20241  else
20242  {
20243  nativeFmt = null;
20244  }
20245 
20246  ImGuiNative.igText(nativeFmt);
20247  if (fmtByteCount > Util.StackAllocationSizeLimit)
20248  {
20249  Util.Free(nativeFmt);
20250  }
20251  }
20252 
20258  public static void TextColored(Vector4F col, string fmt)
20259  {
20260  byte* nativeFmt;
20261  int fmtByteCount = 0;
20262  if (fmt != null)
20263  {
20264  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20265  if (fmtByteCount > Util.StackAllocationSizeLimit)
20266  {
20267  nativeFmt = Util.Allocate(fmtByteCount + 1);
20268  }
20269  else
20270  {
20271  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20272  nativeFmt = nativeFmtStackBytes;
20273  }
20274 
20275  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20276  nativeFmt[nativeFmtOffset] = 0;
20277  }
20278  else
20279  {
20280  nativeFmt = null;
20281  }
20282 
20283  ImGuiNative.igTextColored(col, nativeFmt);
20284  if (fmtByteCount > Util.StackAllocationSizeLimit)
20285  {
20286  Util.Free(nativeFmt);
20287  }
20288  }
20289 
20294  public static void TextDisabled(string fmt)
20295  {
20296  byte* nativeFmt;
20297  int fmtByteCount = 0;
20298  if (fmt != null)
20299  {
20300  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20301  if (fmtByteCount > Util.StackAllocationSizeLimit)
20302  {
20303  nativeFmt = Util.Allocate(fmtByteCount + 1);
20304  }
20305  else
20306  {
20307  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20308  nativeFmt = nativeFmtStackBytes;
20309  }
20310 
20311  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20312  nativeFmt[nativeFmtOffset] = 0;
20313  }
20314  else
20315  {
20316  nativeFmt = null;
20317  }
20318 
20319  ImGuiNative.igTextDisabled(nativeFmt);
20320  if (fmtByteCount > Util.StackAllocationSizeLimit)
20321  {
20322  Util.Free(nativeFmt);
20323  }
20324  }
20325 
20330  public static void TextUnformatted(string text)
20331  {
20332  byte* nativeText;
20333  int textByteCount = 0;
20334  if (text != null)
20335  {
20336  textByteCount = Encoding.UTF8.GetByteCount(text);
20337  if (textByteCount > Util.StackAllocationSizeLimit)
20338  {
20339  nativeText = Util.Allocate(textByteCount + 1);
20340  }
20341  else
20342  {
20343  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
20344  nativeText = nativeTextStackBytes;
20345  }
20346 
20347  int nativeTextOffset = Util.GetUtf8(text, nativeText, textByteCount);
20348  nativeText[nativeTextOffset] = 0;
20349  }
20350  else
20351  {
20352  nativeText = null;
20353  }
20354 
20355  byte* nativeTextEnd = null;
20356  ImGuiNative.igTextUnformatted(nativeText, nativeTextEnd);
20357  if (textByteCount > Util.StackAllocationSizeLimit)
20358  {
20359  Util.Free(nativeText);
20360  }
20361  }
20362 
20367  public static void TextWrapped(string fmt)
20368  {
20369  byte* nativeFmt;
20370  int fmtByteCount = 0;
20371  if (fmt != null)
20372  {
20373  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20374  if (fmtByteCount > Util.StackAllocationSizeLimit)
20375  {
20376  nativeFmt = Util.Allocate(fmtByteCount + 1);
20377  }
20378  else
20379  {
20380  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20381  nativeFmt = nativeFmtStackBytes;
20382  }
20383 
20384  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20385  nativeFmt[nativeFmtOffset] = 0;
20386  }
20387  else
20388  {
20389  nativeFmt = null;
20390  }
20391 
20392  ImGuiNative.igTextWrapped(nativeFmt);
20393  if (fmtByteCount > Util.StackAllocationSizeLimit)
20394  {
20395  Util.Free(nativeFmt);
20396  }
20397  }
20398 
20404  public static bool TreeNode(string label)
20405  {
20406  byte* nativeLabel;
20407  int labelByteCount = 0;
20408  if (label != null)
20409  {
20410  labelByteCount = Encoding.UTF8.GetByteCount(label);
20411  if (labelByteCount > Util.StackAllocationSizeLimit)
20412  {
20413  nativeLabel = Util.Allocate(labelByteCount + 1);
20414  }
20415  else
20416  {
20417  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20418  nativeLabel = nativeLabelStackBytes;
20419  }
20420 
20421  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20422  nativeLabel[nativeLabelOffset] = 0;
20423  }
20424  else
20425  {
20426  nativeLabel = null;
20427  }
20428 
20429  byte ret = ImGuiNative.igTreeNode_Str(nativeLabel);
20430  if (labelByteCount > Util.StackAllocationSizeLimit)
20431  {
20432  Util.Free(nativeLabel);
20433  }
20434 
20435  return ret != 0;
20436  }
20437 
20444  public static bool TreeNode(string strId, string fmt)
20445  {
20446  byte* nativeStrId;
20447  int strIdByteCount = 0;
20448  if (strId != null)
20449  {
20450  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20451  if (strIdByteCount > Util.StackAllocationSizeLimit)
20452  {
20453  nativeStrId = Util.Allocate(strIdByteCount + 1);
20454  }
20455  else
20456  {
20457  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20458  nativeStrId = nativeStrIdStackBytes;
20459  }
20460 
20461  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20462  nativeStrId[nativeStrIdOffset] = 0;
20463  }
20464  else
20465  {
20466  nativeStrId = null;
20467  }
20468 
20469  byte* nativeFmt;
20470  int fmtByteCount = 0;
20471  if (fmt != null)
20472  {
20473  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20474  if (fmtByteCount > Util.StackAllocationSizeLimit)
20475  {
20476  nativeFmt = Util.Allocate(fmtByteCount + 1);
20477  }
20478  else
20479  {
20480  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20481  nativeFmt = nativeFmtStackBytes;
20482  }
20483 
20484  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20485  nativeFmt[nativeFmtOffset] = 0;
20486  }
20487  else
20488  {
20489  nativeFmt = null;
20490  }
20491 
20492  byte ret = ImGuiNative.igTreeNode_StrStr(nativeStrId, nativeFmt);
20493  if (strIdByteCount > Util.StackAllocationSizeLimit)
20494  {
20495  Util.Free(nativeStrId);
20496  }
20497 
20498  if (fmtByteCount > Util.StackAllocationSizeLimit)
20499  {
20500  Util.Free(nativeFmt);
20501  }
20502 
20503  return ret != 0;
20504  }
20505 
20512  public static bool TreeNode(IntPtr ptrId, string fmt)
20513  {
20514  void* nativePtrId = ptrId.ToPointer();
20515  byte* nativeFmt;
20516  int fmtByteCount = 0;
20517  if (fmt != null)
20518  {
20519  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20520  if (fmtByteCount > Util.StackAllocationSizeLimit)
20521  {
20522  nativeFmt = Util.Allocate(fmtByteCount + 1);
20523  }
20524  else
20525  {
20526  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20527  nativeFmt = nativeFmtStackBytes;
20528  }
20529 
20530  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20531  nativeFmt[nativeFmtOffset] = 0;
20532  }
20533  else
20534  {
20535  nativeFmt = null;
20536  }
20537 
20538  byte ret = ImGuiNative.igTreeNode_Ptr(nativePtrId, nativeFmt);
20539  if (fmtByteCount > Util.StackAllocationSizeLimit)
20540  {
20541  Util.Free(nativeFmt);
20542  }
20543 
20544  return ret != 0;
20545  }
20546 
20552  public static bool TreeNodeEx(string label)
20553  {
20554  byte* nativeLabel;
20555  int labelByteCount = 0;
20556  if (label != null)
20557  {
20558  labelByteCount = Encoding.UTF8.GetByteCount(label);
20559  if (labelByteCount > Util.StackAllocationSizeLimit)
20560  {
20561  nativeLabel = Util.Allocate(labelByteCount + 1);
20562  }
20563  else
20564  {
20565  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20566  nativeLabel = nativeLabelStackBytes;
20567  }
20568 
20569  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20570  nativeLabel[nativeLabelOffset] = 0;
20571  }
20572  else
20573  {
20574  nativeLabel = null;
20575  }
20576 
20577  ImGuiTreeNodes flag = 0;
20578  byte ret = ImGuiNative.igTreeNodeEx_Str(nativeLabel, flag);
20579  if (labelByteCount > Util.StackAllocationSizeLimit)
20580  {
20581  Util.Free(nativeLabel);
20582  }
20583 
20584  return ret != 0;
20585  }
20586 
20593  public static bool TreeNodeEx(string label, ImGuiTreeNodes flag)
20594  {
20595  byte* nativeLabel;
20596  int labelByteCount = 0;
20597  if (label != null)
20598  {
20599  labelByteCount = Encoding.UTF8.GetByteCount(label);
20600  if (labelByteCount > Util.StackAllocationSizeLimit)
20601  {
20602  nativeLabel = Util.Allocate(labelByteCount + 1);
20603  }
20604  else
20605  {
20606  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
20607  nativeLabel = nativeLabelStackBytes;
20608  }
20609 
20610  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
20611  nativeLabel[nativeLabelOffset] = 0;
20612  }
20613  else
20614  {
20615  nativeLabel = null;
20616  }
20617 
20618  byte ret = ImGuiNative.igTreeNodeEx_Str(nativeLabel, flag);
20619  if (labelByteCount > Util.StackAllocationSizeLimit)
20620  {
20621  Util.Free(nativeLabel);
20622  }
20623 
20624  return ret != 0;
20625  }
20626 
20634  public static bool TreeNodeEx(string strId, ImGuiTreeNodes flag, string fmt)
20635  {
20636  byte* nativeStrId;
20637  int strIdByteCount = 0;
20638  if (strId != null)
20639  {
20640  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20641  if (strIdByteCount > Util.StackAllocationSizeLimit)
20642  {
20643  nativeStrId = Util.Allocate(strIdByteCount + 1);
20644  }
20645  else
20646  {
20647  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20648  nativeStrId = nativeStrIdStackBytes;
20649  }
20650 
20651  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20652  nativeStrId[nativeStrIdOffset] = 0;
20653  }
20654  else
20655  {
20656  nativeStrId = null;
20657  }
20658 
20659  byte* nativeFmt;
20660  int fmtByteCount = 0;
20661  if (fmt != null)
20662  {
20663  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20664  if (fmtByteCount > Util.StackAllocationSizeLimit)
20665  {
20666  nativeFmt = Util.Allocate(fmtByteCount + 1);
20667  }
20668  else
20669  {
20670  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20671  nativeFmt = nativeFmtStackBytes;
20672  }
20673 
20674  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20675  nativeFmt[nativeFmtOffset] = 0;
20676  }
20677  else
20678  {
20679  nativeFmt = null;
20680  }
20681 
20682  byte ret = ImGuiNative.igTreeNodeEx_StrStr(nativeStrId, flag, nativeFmt);
20683  if (strIdByteCount > Util.StackAllocationSizeLimit)
20684  {
20685  Util.Free(nativeStrId);
20686  }
20687 
20688  if (fmtByteCount > Util.StackAllocationSizeLimit)
20689  {
20690  Util.Free(nativeFmt);
20691  }
20692 
20693  return ret != 0;
20694  }
20695 
20703  public static bool TreeNodeEx(IntPtr ptrId, ImGuiTreeNodes flag, string fmt)
20704  {
20705  void* nativePtrId = ptrId.ToPointer();
20706  byte* nativeFmt;
20707  int fmtByteCount = 0;
20708  if (fmt != null)
20709  {
20710  fmtByteCount = Encoding.UTF8.GetByteCount(fmt);
20711  if (fmtByteCount > Util.StackAllocationSizeLimit)
20712  {
20713  nativeFmt = Util.Allocate(fmtByteCount + 1);
20714  }
20715  else
20716  {
20717  byte* nativeFmtStackBytes = stackalloc byte[fmtByteCount + 1];
20718  nativeFmt = nativeFmtStackBytes;
20719  }
20720 
20721  int nativeFmtOffset = Util.GetUtf8(fmt, nativeFmt, fmtByteCount);
20722  nativeFmt[nativeFmtOffset] = 0;
20723  }
20724  else
20725  {
20726  nativeFmt = null;
20727  }
20728 
20729  byte ret = ImGuiNative.igTreeNodeEx_Ptr(nativePtrId, flag, nativeFmt);
20730  if (fmtByteCount > Util.StackAllocationSizeLimit)
20731  {
20732  Util.Free(nativeFmt);
20733  }
20734 
20735  return ret != 0;
20736  }
20737 
20741  public static void TreePop()
20742  {
20744  }
20745 
20750  public static void TreePush(string strId)
20751  {
20752  byte* nativeStrId;
20753  int strIdByteCount = 0;
20754  if (strId != null)
20755  {
20756  strIdByteCount = Encoding.UTF8.GetByteCount(strId);
20757  if (strIdByteCount > Util.StackAllocationSizeLimit)
20758  {
20759  nativeStrId = Util.Allocate(strIdByteCount + 1);
20760  }
20761  else
20762  {
20763  byte* nativeStrIdStackBytes = stackalloc byte[strIdByteCount + 1];
20764  nativeStrId = nativeStrIdStackBytes;
20765  }
20766 
20767  int nativeStrIdOffset = Util.GetUtf8(strId, nativeStrId, strIdByteCount);
20768  nativeStrId[nativeStrIdOffset] = 0;
20769  }
20770  else
20771  {
20772  nativeStrId = null;
20773  }
20774 
20775  ImGuiNative.igTreePush_Str(nativeStrId);
20776  if (strIdByteCount > Util.StackAllocationSizeLimit)
20777  {
20778  Util.Free(nativeStrId);
20779  }
20780  }
20781 
20786  public static void TreePush(IntPtr ptrId)
20787  {
20788  void* nativePtrId = ptrId.ToPointer();
20789  ImGuiNative.igTreePush_Ptr(nativePtrId);
20790  }
20791 
20795  public static void Unindent()
20796  {
20797  float indentW = 0.0f;
20798  ImGuiNative.igUnindent(indentW);
20799  }
20800 
20805  public static void Unindent(float indentW)
20806  {
20807  ImGuiNative.igUnindent(indentW);
20808  }
20809 
20813  public static void UpdatePlatformWindows()
20814  {
20816  }
20817 
20823  public static void Value(string prefix, bool b)
20824  {
20825  byte* nativePrefix;
20826  int prefixByteCount = 0;
20827  if (prefix != null)
20828  {
20829  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20830  if (prefixByteCount > Util.StackAllocationSizeLimit)
20831  {
20832  nativePrefix = Util.Allocate(prefixByteCount + 1);
20833  }
20834  else
20835  {
20836  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20837  nativePrefix = nativePrefixStackBytes;
20838  }
20839 
20840  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20841  nativePrefix[nativePrefixOffset] = 0;
20842  }
20843  else
20844  {
20845  nativePrefix = null;
20846  }
20847 
20848  byte nativeB = b ? (byte) 1 : (byte) 0;
20849  ImGuiNative.igValue_Bool(nativePrefix, nativeB);
20850  if (prefixByteCount > Util.StackAllocationSizeLimit)
20851  {
20852  Util.Free(nativePrefix);
20853  }
20854  }
20855 
20861  public static void Value(string prefix, int v)
20862  {
20863  byte* nativePrefix;
20864  int prefixByteCount = 0;
20865  if (prefix != null)
20866  {
20867  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20868  if (prefixByteCount > Util.StackAllocationSizeLimit)
20869  {
20870  nativePrefix = Util.Allocate(prefixByteCount + 1);
20871  }
20872  else
20873  {
20874  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20875  nativePrefix = nativePrefixStackBytes;
20876  }
20877 
20878  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20879  nativePrefix[nativePrefixOffset] = 0;
20880  }
20881  else
20882  {
20883  nativePrefix = null;
20884  }
20885 
20886  ImGuiNative.igValue_Int(nativePrefix, v);
20887  if (prefixByteCount > Util.StackAllocationSizeLimit)
20888  {
20889  Util.Free(nativePrefix);
20890  }
20891  }
20892 
20898  public static void Value(string prefix, uint v)
20899  {
20900  byte* nativePrefix;
20901  int prefixByteCount = 0;
20902  if (prefix != null)
20903  {
20904  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20905  if (prefixByteCount > Util.StackAllocationSizeLimit)
20906  {
20907  nativePrefix = Util.Allocate(prefixByteCount + 1);
20908  }
20909  else
20910  {
20911  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20912  nativePrefix = nativePrefixStackBytes;
20913  }
20914 
20915  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20916  nativePrefix[nativePrefixOffset] = 0;
20917  }
20918  else
20919  {
20920  nativePrefix = null;
20921  }
20922 
20923  ImGuiNative.igValue_Uint(nativePrefix, v);
20924  if (prefixByteCount > Util.StackAllocationSizeLimit)
20925  {
20926  Util.Free(nativePrefix);
20927  }
20928  }
20929 
20935  public static void Value(string prefix, float v)
20936  {
20937  byte* nativePrefix;
20938  int prefixByteCount = 0;
20939  if (prefix != null)
20940  {
20941  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20942  if (prefixByteCount > Util.StackAllocationSizeLimit)
20943  {
20944  nativePrefix = Util.Allocate(prefixByteCount + 1);
20945  }
20946  else
20947  {
20948  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20949  nativePrefix = nativePrefixStackBytes;
20950  }
20951 
20952  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20953  nativePrefix[nativePrefixOffset] = 0;
20954  }
20955  else
20956  {
20957  nativePrefix = null;
20958  }
20959 
20960  byte* nativeFloatFormat = null;
20961  ImGuiNative.igValue_Float(nativePrefix, v, nativeFloatFormat);
20962  if (prefixByteCount > Util.StackAllocationSizeLimit)
20963  {
20964  Util.Free(nativePrefix);
20965  }
20966  }
20967 
20974  public static void Value(string prefix, float v, string floatFormat)
20975  {
20976  byte* nativePrefix;
20977  int prefixByteCount = 0;
20978  if (prefix != null)
20979  {
20980  prefixByteCount = Encoding.UTF8.GetByteCount(prefix);
20981  if (prefixByteCount > Util.StackAllocationSizeLimit)
20982  {
20983  nativePrefix = Util.Allocate(prefixByteCount + 1);
20984  }
20985  else
20986  {
20987  byte* nativePrefixStackBytes = stackalloc byte[prefixByteCount + 1];
20988  nativePrefix = nativePrefixStackBytes;
20989  }
20990 
20991  int nativePrefixOffset = Util.GetUtf8(prefix, nativePrefix, prefixByteCount);
20992  nativePrefix[nativePrefixOffset] = 0;
20993  }
20994  else
20995  {
20996  nativePrefix = null;
20997  }
20998 
20999  byte* nativeFloatFormat;
21000  int floatFormatByteCount = 0;
21001  if (floatFormat != null)
21002  {
21003  floatFormatByteCount = Encoding.UTF8.GetByteCount(floatFormat);
21004  if (floatFormatByteCount > Util.StackAllocationSizeLimit)
21005  {
21006  nativeFloatFormat = Util.Allocate(floatFormatByteCount + 1);
21007  }
21008  else
21009  {
21010  byte* nativeFloatFormatStackBytes = stackalloc byte[floatFormatByteCount + 1];
21011  nativeFloatFormat = nativeFloatFormatStackBytes;
21012  }
21013 
21014  int nativeFloatFormatOffset = Util.GetUtf8(floatFormat, nativeFloatFormat, floatFormatByteCount);
21015  nativeFloatFormat[nativeFloatFormatOffset] = 0;
21016  }
21017  else
21018  {
21019  nativeFloatFormat = null;
21020  }
21021 
21022  ImGuiNative.igValue_Float(nativePrefix, v, nativeFloatFormat);
21023  if (prefixByteCount > Util.StackAllocationSizeLimit)
21024  {
21025  Util.Free(nativePrefix);
21026  }
21027 
21028  if (floatFormatByteCount > Util.StackAllocationSizeLimit)
21029  {
21030  Util.Free(nativeFloatFormat);
21031  }
21032  }
21033 
21043  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax)
21044  {
21045  byte* nativeLabel;
21046  int labelByteCount = 0;
21047  if (label != null)
21048  {
21049  labelByteCount = Encoding.UTF8.GetByteCount(label);
21050  if (labelByteCount > Util.StackAllocationSizeLimit)
21051  {
21052  nativeLabel = Util.Allocate(labelByteCount + 1);
21053  }
21054  else
21055  {
21056  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21057  nativeLabel = nativeLabelStackBytes;
21058  }
21059 
21060  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21061  nativeLabel[nativeLabelOffset] = 0;
21062  }
21063  else
21064  {
21065  nativeLabel = null;
21066  }
21067 
21068  byte* nativeFormat;
21069  int formatByteCount = 0;
21070  formatByteCount = Encoding.UTF8.GetByteCount("%.3f");
21071  if (formatByteCount > Util.StackAllocationSizeLimit)
21072  {
21073  nativeFormat = Util.Allocate(formatByteCount + 1);
21074  }
21075  else
21076  {
21077  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21078  nativeFormat = nativeFormatStackBytes;
21079  }
21080 
21081  int nativeFormatOffset = Util.GetUtf8("%.3f", nativeFormat, formatByteCount);
21082  nativeFormat[nativeFormatOffset] = 0;
21083  ImGuiSliders flag = 0;
21084  fixed (float* nativeV = &v)
21085  {
21086  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21087  if (labelByteCount > Util.StackAllocationSizeLimit)
21088  {
21089  Util.Free(nativeLabel);
21090  }
21091 
21092  if (formatByteCount > Util.StackAllocationSizeLimit)
21093  {
21094  Util.Free(nativeFormat);
21095  }
21096 
21097  return ret != 0;
21098  }
21099  }
21100 
21111  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format)
21112  {
21113  byte* nativeLabel;
21114  int labelByteCount = 0;
21115  if (label != null)
21116  {
21117  labelByteCount = Encoding.UTF8.GetByteCount(label);
21118  if (labelByteCount > Util.StackAllocationSizeLimit)
21119  {
21120  nativeLabel = Util.Allocate(labelByteCount + 1);
21121  }
21122  else
21123  {
21124  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21125  nativeLabel = nativeLabelStackBytes;
21126  }
21127 
21128  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21129  nativeLabel[nativeLabelOffset] = 0;
21130  }
21131  else
21132  {
21133  nativeLabel = null;
21134  }
21135 
21136  byte* nativeFormat;
21137  int formatByteCount = 0;
21138  if (format != null)
21139  {
21140  formatByteCount = Encoding.UTF8.GetByteCount(format);
21141  if (formatByteCount > Util.StackAllocationSizeLimit)
21142  {
21143  nativeFormat = Util.Allocate(formatByteCount + 1);
21144  }
21145  else
21146  {
21147  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21148  nativeFormat = nativeFormatStackBytes;
21149  }
21150 
21151  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21152  nativeFormat[nativeFormatOffset] = 0;
21153  }
21154  else
21155  {
21156  nativeFormat = null;
21157  }
21158 
21159  ImGuiSliders flag = 0;
21160  fixed (float* nativeV = &v)
21161  {
21162  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21163  if (labelByteCount > Util.StackAllocationSizeLimit)
21164  {
21165  Util.Free(nativeLabel);
21166  }
21167 
21168  if (formatByteCount > Util.StackAllocationSizeLimit)
21169  {
21170  Util.Free(nativeFormat);
21171  }
21172 
21173  return ret != 0;
21174  }
21175  }
21176 
21188  public static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format, ImGuiSliders flag)
21189  {
21190  byte* nativeLabel;
21191  int labelByteCount = 0;
21192  if (label != null)
21193  {
21194  labelByteCount = Encoding.UTF8.GetByteCount(label);
21195  if (labelByteCount > Util.StackAllocationSizeLimit)
21196  {
21197  nativeLabel = Util.Allocate(labelByteCount + 1);
21198  }
21199  else
21200  {
21201  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21202  nativeLabel = nativeLabelStackBytes;
21203  }
21204 
21205  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21206  nativeLabel[nativeLabelOffset] = 0;
21207  }
21208  else
21209  {
21210  nativeLabel = null;
21211  }
21212 
21213  byte* nativeFormat;
21214  int formatByteCount = 0;
21215  if (format != null)
21216  {
21217  formatByteCount = Encoding.UTF8.GetByteCount(format);
21218  if (formatByteCount > Util.StackAllocationSizeLimit)
21219  {
21220  nativeFormat = Util.Allocate(formatByteCount + 1);
21221  }
21222  else
21223  {
21224  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21225  nativeFormat = nativeFormatStackBytes;
21226  }
21227 
21228  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21229  nativeFormat[nativeFormatOffset] = 0;
21230  }
21231  else
21232  {
21233  nativeFormat = null;
21234  }
21235 
21236  fixed (float* nativeV = &v)
21237  {
21238  byte ret = ImGuiNative.igVSliderFloat(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21239  if (labelByteCount > Util.StackAllocationSizeLimit)
21240  {
21241  Util.Free(nativeLabel);
21242  }
21243 
21244  if (formatByteCount > Util.StackAllocationSizeLimit)
21245  {
21246  Util.Free(nativeFormat);
21247  }
21248 
21249  return ret != 0;
21250  }
21251  }
21252 
21262  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax)
21263  {
21264  byte* nativeLabel;
21265  int labelByteCount = 0;
21266  if (label != null)
21267  {
21268  labelByteCount = Encoding.UTF8.GetByteCount(label);
21269  if (labelByteCount > Util.StackAllocationSizeLimit)
21270  {
21271  nativeLabel = Util.Allocate(labelByteCount + 1);
21272  }
21273  else
21274  {
21275  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21276  nativeLabel = nativeLabelStackBytes;
21277  }
21278 
21279  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21280  nativeLabel[nativeLabelOffset] = 0;
21281  }
21282  else
21283  {
21284  nativeLabel = null;
21285  }
21286 
21287  byte* nativeFormat;
21288  int formatByteCount = 0;
21289  formatByteCount = Encoding.UTF8.GetByteCount("%d");
21290  if (formatByteCount > Util.StackAllocationSizeLimit)
21291  {
21292  nativeFormat = Util.Allocate(formatByteCount + 1);
21293  }
21294  else
21295  {
21296  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21297  nativeFormat = nativeFormatStackBytes;
21298  }
21299 
21300  int nativeFormatOffset = Util.GetUtf8("%d", nativeFormat, formatByteCount);
21301  nativeFormat[nativeFormatOffset] = 0;
21302  ImGuiSliders flag = 0;
21303  fixed (int* nativeV = &v)
21304  {
21305  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21306  if (labelByteCount > Util.StackAllocationSizeLimit)
21307  {
21308  Util.Free(nativeLabel);
21309  }
21310 
21311  if (formatByteCount > Util.StackAllocationSizeLimit)
21312  {
21313  Util.Free(nativeFormat);
21314  }
21315 
21316  return ret != 0;
21317  }
21318  }
21319 
21330  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format)
21331  {
21332  byte* nativeLabel;
21333  int labelByteCount = 0;
21334  if (label != null)
21335  {
21336  labelByteCount = Encoding.UTF8.GetByteCount(label);
21337  if (labelByteCount > Util.StackAllocationSizeLimit)
21338  {
21339  nativeLabel = Util.Allocate(labelByteCount + 1);
21340  }
21341  else
21342  {
21343  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21344  nativeLabel = nativeLabelStackBytes;
21345  }
21346 
21347  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21348  nativeLabel[nativeLabelOffset] = 0;
21349  }
21350  else
21351  {
21352  nativeLabel = null;
21353  }
21354 
21355  byte* nativeFormat;
21356  int formatByteCount = 0;
21357  if (format != null)
21358  {
21359  formatByteCount = Encoding.UTF8.GetByteCount(format);
21360  if (formatByteCount > Util.StackAllocationSizeLimit)
21361  {
21362  nativeFormat = Util.Allocate(formatByteCount + 1);
21363  }
21364  else
21365  {
21366  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21367  nativeFormat = nativeFormatStackBytes;
21368  }
21369 
21370  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21371  nativeFormat[nativeFormatOffset] = 0;
21372  }
21373  else
21374  {
21375  nativeFormat = null;
21376  }
21377 
21378  ImGuiSliders flag = 0;
21379  fixed (int* nativeV = &v)
21380  {
21381  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21382  if (labelByteCount > Util.StackAllocationSizeLimit)
21383  {
21384  Util.Free(nativeLabel);
21385  }
21386 
21387  if (formatByteCount > Util.StackAllocationSizeLimit)
21388  {
21389  Util.Free(nativeFormat);
21390  }
21391 
21392  return ret != 0;
21393  }
21394  }
21395 
21407  public static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
21408  {
21409  byte* nativeLabel;
21410  int labelByteCount = 0;
21411  if (label != null)
21412  {
21413  labelByteCount = Encoding.UTF8.GetByteCount(label);
21414  if (labelByteCount > Util.StackAllocationSizeLimit)
21415  {
21416  nativeLabel = Util.Allocate(labelByteCount + 1);
21417  }
21418  else
21419  {
21420  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21421  nativeLabel = nativeLabelStackBytes;
21422  }
21423 
21424  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21425  nativeLabel[nativeLabelOffset] = 0;
21426  }
21427  else
21428  {
21429  nativeLabel = null;
21430  }
21431 
21432  byte* nativeFormat;
21433  int formatByteCount = 0;
21434  if (format != null)
21435  {
21436  formatByteCount = Encoding.UTF8.GetByteCount(format);
21437  if (formatByteCount > Util.StackAllocationSizeLimit)
21438  {
21439  nativeFormat = Util.Allocate(formatByteCount + 1);
21440  }
21441  else
21442  {
21443  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21444  nativeFormat = nativeFormatStackBytes;
21445  }
21446 
21447  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21448  nativeFormat[nativeFormatOffset] = 0;
21449  }
21450  else
21451  {
21452  nativeFormat = null;
21453  }
21454 
21455  fixed (int* nativeV = &v)
21456  {
21457  byte ret = ImGuiNative.igVSliderInt(nativeLabel, size, nativeV, vMin, vMax, nativeFormat, flag);
21458  if (labelByteCount > Util.StackAllocationSizeLimit)
21459  {
21460  Util.Free(nativeLabel);
21461  }
21462 
21463  if (formatByteCount > Util.StackAllocationSizeLimit)
21464  {
21465  Util.Free(nativeFormat);
21466  }
21467 
21468  return ret != 0;
21469  }
21470  }
21471 
21482  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
21483  {
21484  byte* nativeLabel;
21485  int labelByteCount = 0;
21486  if (label != null)
21487  {
21488  labelByteCount = Encoding.UTF8.GetByteCount(label);
21489  if (labelByteCount > Util.StackAllocationSizeLimit)
21490  {
21491  nativeLabel = Util.Allocate(labelByteCount + 1);
21492  }
21493  else
21494  {
21495  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21496  nativeLabel = nativeLabelStackBytes;
21497  }
21498 
21499  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21500  nativeLabel[nativeLabelOffset] = 0;
21501  }
21502  else
21503  {
21504  nativeLabel = null;
21505  }
21506 
21507  void* nativePData = pData.ToPointer();
21508  void* nativePMin = pMin.ToPointer();
21509  void* nativePMax = pMax.ToPointer();
21510  byte* nativeFormat = null;
21511  ImGuiSliders flag = 0;
21512  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
21513  if (labelByteCount > Util.StackAllocationSizeLimit)
21514  {
21515  Util.Free(nativeLabel);
21516  }
21517 
21518  return ret != 0;
21519  }
21520 
21532  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
21533  {
21534  byte* nativeLabel;
21535  int labelByteCount = 0;
21536  if (label != null)
21537  {
21538  labelByteCount = Encoding.UTF8.GetByteCount(label);
21539  if (labelByteCount > Util.StackAllocationSizeLimit)
21540  {
21541  nativeLabel = Util.Allocate(labelByteCount + 1);
21542  }
21543  else
21544  {
21545  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21546  nativeLabel = nativeLabelStackBytes;
21547  }
21548 
21549  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21550  nativeLabel[nativeLabelOffset] = 0;
21551  }
21552  else
21553  {
21554  nativeLabel = null;
21555  }
21556 
21557  void* nativePData = pData.ToPointer();
21558  void* nativePMin = pMin.ToPointer();
21559  void* nativePMax = pMax.ToPointer();
21560  byte* nativeFormat;
21561  int formatByteCount = 0;
21562  if (format != null)
21563  {
21564  formatByteCount = Encoding.UTF8.GetByteCount(format);
21565  if (formatByteCount > Util.StackAllocationSizeLimit)
21566  {
21567  nativeFormat = Util.Allocate(formatByteCount + 1);
21568  }
21569  else
21570  {
21571  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21572  nativeFormat = nativeFormatStackBytes;
21573  }
21574 
21575  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21576  nativeFormat[nativeFormatOffset] = 0;
21577  }
21578  else
21579  {
21580  nativeFormat = null;
21581  }
21582 
21583  ImGuiSliders flag = 0;
21584  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
21585  if (labelByteCount > Util.StackAllocationSizeLimit)
21586  {
21587  Util.Free(nativeLabel);
21588  }
21589 
21590  if (formatByteCount > Util.StackAllocationSizeLimit)
21591  {
21592  Util.Free(nativeFormat);
21593  }
21594 
21595  return ret != 0;
21596  }
21597 
21610  public static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
21611  {
21612  byte* nativeLabel;
21613  int labelByteCount = 0;
21614  if (label != null)
21615  {
21616  labelByteCount = Encoding.UTF8.GetByteCount(label);
21617  if (labelByteCount > Util.StackAllocationSizeLimit)
21618  {
21619  nativeLabel = Util.Allocate(labelByteCount + 1);
21620  }
21621  else
21622  {
21623  byte* nativeLabelStackBytes = stackalloc byte[labelByteCount + 1];
21624  nativeLabel = nativeLabelStackBytes;
21625  }
21626 
21627  int nativeLabelOffset = Util.GetUtf8(label, nativeLabel, labelByteCount);
21628  nativeLabel[nativeLabelOffset] = 0;
21629  }
21630  else
21631  {
21632  nativeLabel = null;
21633  }
21634 
21635  void* nativePData = pData.ToPointer();
21636  void* nativePMin = pMin.ToPointer();
21637  void* nativePMax = pMax.ToPointer();
21638  byte* nativeFormat;
21639  int formatByteCount = 0;
21640  if (format != null)
21641  {
21642  formatByteCount = Encoding.UTF8.GetByteCount(format);
21643  if (formatByteCount > Util.StackAllocationSizeLimit)
21644  {
21645  nativeFormat = Util.Allocate(formatByteCount + 1);
21646  }
21647  else
21648  {
21649  byte* nativeFormatStackBytes = stackalloc byte[formatByteCount + 1];
21650  nativeFormat = nativeFormatStackBytes;
21651  }
21652 
21653  int nativeFormatOffset = Util.GetUtf8(format, nativeFormat, formatByteCount);
21654  nativeFormat[nativeFormatOffset] = 0;
21655  }
21656  else
21657  {
21658  nativeFormat = null;
21659  }
21660 
21661  byte ret = ImGuiNative.igVSliderScalar(nativeLabel, size, dataType, nativePData, nativePMin, nativePMax, nativeFormat, flag);
21662  if (labelByteCount > Util.StackAllocationSizeLimit)
21663  {
21664  Util.Free(nativeLabel);
21665  }
21666 
21667  if (formatByteCount > Util.StackAllocationSizeLimit)
21668  {
21669  Util.Free(nativeFormat);
21670  }
21671 
21672  return ret != 0;
21673  }
21674 
21682  public static bool InputText(
21683  string label,
21684  byte[] buf,
21685  uint bufSize)
21686  => InputText(label, buf, bufSize, 0, null, IntPtr.Zero);
21687 
21696  public static bool InputText(
21697  string label,
21698  byte[] buf,
21699  uint bufSize,
21700  ImGuiInputTexts flag)
21701  => InputText(label, buf, bufSize, flag, null, IntPtr.Zero);
21702 
21712  public static bool InputText(
21713  string label,
21714  byte[] buf,
21715  uint bufSize,
21716  ImGuiInputTexts flag,
21717  ImGuiInputTextCallback callback)
21718  => InputText(label, buf, bufSize, flag, callback, IntPtr.Zero);
21719 
21730  public static bool InputText(
21731  string label,
21732  byte[] buf,
21733  uint bufSize,
21734  ImGuiInputTexts flag,
21735  ImGuiInputTextCallback callback,
21736  IntPtr userData)
21737  {
21738  int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
21739  byte* utf8LabelBytes;
21740  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
21741  {
21742  utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
21743  }
21744  else
21745  {
21746  byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
21747  utf8LabelBytes = stackPtr;
21748  }
21749 
21750  Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
21751 
21752  bool ret;
21753  fixed (byte* bufPtr = buf)
21754  {
21755  ret = ImGuiNative.igInputText(utf8LabelBytes, bufPtr, bufSize, flag, callback, userData.ToPointer()) != 0;
21756  }
21757 
21758  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
21759  {
21760  Util.Free(utf8LabelBytes);
21761  }
21762 
21763  return ret;
21764  }
21765 
21773  public static bool InputText(
21774  string label,
21775  ref string input,
21776  uint maxLength) => InputText(label, ref input, maxLength, 0, null, IntPtr.Zero);
21777 
21786  public static bool InputText(
21787  string label,
21788  ref string input,
21789  uint maxLength,
21790  ImGuiInputTexts flag) => InputText(label, ref input, maxLength, flag, null, IntPtr.Zero);
21791 
21801  public static bool InputText(
21802  string label,
21803  ref string input,
21804  uint maxLength,
21805  ImGuiInputTexts flag,
21806  ImGuiInputTextCallback callback) => InputText(label, ref input, maxLength, flag, callback, IntPtr.Zero);
21807 
21818  public static bool InputText(
21819  string label,
21820  ref string input,
21821  uint maxLength,
21822  ImGuiInputTexts flag,
21823  ImGuiInputTextCallback callback,
21824  IntPtr userData)
21825  {
21826  // Convert label and input to ANSI strings
21827  IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21828  IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21829 
21830  // Convert ANSI strings to UTF-8 bytes
21831  byte* utf8LabelBytes = (byte*) labelPtr.ToPointer();
21832  byte* utf8InputBytes = (byte*) inputPtr.ToPointer();
21833 
21834  // Create buffers for modified input
21835  int inputBufSize = Math.Max((int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21836  byte* modifiedUtf8InputBytes = stackalloc byte[inputBufSize];
21837  byte* originalUtf8InputBytes = stackalloc byte[inputBufSize];
21838 
21839  // Copy input bytes to the modified input buffer
21840  Unsafe.CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21841 
21842  // Call the ImGuiNative method
21843  byte result = ImGuiNative.igInputText(
21844  utf8LabelBytes,
21845  modifiedUtf8InputBytes,
21846  (uint) inputBufSize,
21847  flag,
21848  callback,
21849  userData.ToPointer());
21850 
21851  // Check if the input was modified and update the input variable accordingly
21852  if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, modifiedUtf8InputBytes))
21853  {
21854  input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21855  }
21856 
21857  // Free the memory allocated by Marshal.StringToHGlobalAnsi
21858  Marshal.FreeHGlobal(labelPtr);
21859  Marshal.FreeHGlobal(inputPtr);
21860 
21861  return result != 0;
21862  }
21863 
21864 
21873  public static bool InputTextMultiline(
21874  string label,
21875  ref string input,
21876  uint maxLength,
21877  Vector2F size) => InputTextMultiline(label, ref input, maxLength, size, 0, null, IntPtr.Zero);
21878 
21888  public static bool InputTextMultiline(
21889  string label,
21890  ref string input,
21891  uint maxLength,
21892  Vector2F size,
21893  ImGuiInputTexts flag) => InputTextMultiline(label, ref input, maxLength, size, flag, null, IntPtr.Zero);
21894 
21905  public static bool InputTextMultiline(
21906  string label,
21907  ref string input,
21908  uint maxLength,
21909  Vector2F size,
21910  ImGuiInputTexts flag,
21911  ImGuiInputTextCallback callback) => InputTextMultiline(label, ref input, maxLength, size, flag, callback, IntPtr.Zero);
21912 
21924  public static bool InputTextMultiline(
21925  string label,
21926  ref string input,
21927  uint maxLength,
21928  Vector2F size,
21929  ImGuiInputTexts flag,
21930  ImGuiInputTextCallback callback,
21931  IntPtr userData)
21932  {
21933  // Convert label and input to ANSI strings
21934  IntPtr labelPtr = Marshal.StringToHGlobalAnsi(label);
21935  IntPtr inputPtr = Marshal.StringToHGlobalAnsi(input);
21936 
21937  // Convert ANSI strings to UTF-8 bytes
21938  byte* utf8LabelBytes = (byte*) labelPtr.ToPointer();
21939  byte* utf8InputBytes = (byte*) inputPtr.ToPointer();
21940 
21941  // Create buffers for modified input
21942  int inputBufSize = Math.Max((int) maxLength + 1, Encoding.UTF8.GetByteCount(input) + 1);
21943  byte* modifiedUtf8InputBytes = stackalloc byte[inputBufSize];
21944  byte* originalUtf8InputBytes = stackalloc byte[inputBufSize];
21945 
21946  // Copy input bytes to the modified input buffer
21947  Unsafe.CopyBlock(modifiedUtf8InputBytes, utf8InputBytes, (uint) inputBufSize);
21948 
21949  // Call the ImGuiNative method
21950  byte result = ImGuiNative.igInputTextMultiline(
21951  utf8LabelBytes,
21952  modifiedUtf8InputBytes,
21953  (uint) inputBufSize,
21954  size,
21955  flag,
21956  callback,
21957  userData.ToPointer());
21958 
21959  // Check if the input was modified and update the input variable accordingly
21960  if (!Util.AreStringsEqual(originalUtf8InputBytes, inputBufSize, modifiedUtf8InputBytes))
21961  {
21962  input = Encoding.UTF8.GetString(modifiedUtf8InputBytes, inputBufSize);
21963  }
21964 
21965  // Free the memory allocated by Marshal.StringToHGlobalAnsi
21966  Marshal.FreeHGlobal(labelPtr);
21967  Marshal.FreeHGlobal(inputPtr);
21968 
21969  return result != 0;
21970  }
21971 
21972 
21979  public static bool AreByteArraysEqual(byte[] array1, byte[] array2)
21980  {
21981  if ((array1 == null) && (array2 == null))
21982  {
21983  return true;
21984  }
21985 
21986  if (array1 == null || array2 == null || array1.Length != array2.Length)
21987  {
21988  return false;
21989  }
21990 
21991  for (int i = 0; i < array1.Length; i++)
21992  {
21993  if (array1[i] != array2[i])
21994  {
21995  return false;
21996  }
21997  }
21998 
21999  return true;
22000  }
22001 
22002 
22011  public static bool InputTextWithHint(
22012  string label,
22013  string hint,
22014  ref string input,
22015  uint maxLength) => InputTextWithHint(label, hint, ref input, maxLength, 0, null, IntPtr.Zero);
22016 
22026  public static bool InputTextWithHint(
22027  string label,
22028  string hint,
22029  ref string input,
22030  uint maxLength,
22031  ImGuiInputTexts flag) => InputTextWithHint(label, hint, ref input, maxLength, flag, null, IntPtr.Zero);
22032 
22043  public static bool InputTextWithHint(
22044  string label,
22045  string hint,
22046  ref string input,
22047  uint maxLength,
22048  ImGuiInputTexts flag,
22049  ImGuiInputTextCallback callback) => InputTextWithHint(label, hint, ref input, maxLength, flag, callback, IntPtr.Zero);
22050 
22062  public static bool InputTextWithHint(
22063  string label,
22064  string hint,
22065  ref string input,
22066  uint maxLength,
22067  ImGuiInputTexts flag,
22068  ImGuiInputTextCallback callback,
22069  IntPtr userData)
22070  {
22071  byte* utf8LabelBytes = GetUtf8Bytes(label);
22072  byte* utf8HintBytes = GetUtf8Bytes(hint);
22073  byte* utf8InputBytes = GetUtf8Bytes(input, maxLength);
22074 
22075  byte result = ImGuiNative.igInputTextWithHint(
22076  utf8LabelBytes,
22077  utf8HintBytes,
22078  utf8InputBytes,
22079  maxLength + 1,
22080  flag,
22081  callback,
22082  userData.ToPointer());
22083 
22084  bool hasInputChanged = !AreUtf8StringsEqual(utf8InputBytes, input);
22085  if (hasInputChanged)
22086  {
22087  input = GetStringFromUtf8(utf8InputBytes);
22088  }
22089 
22090  FreeUtf8Bytes(utf8LabelBytes);
22091  FreeUtf8Bytes(utf8HintBytes);
22092  FreeUtf8Bytes(utf8InputBytes);
22093 
22094  return result != 0;
22095  }
22096 
22102  private static byte* GetUtf8Bytes(string text)
22103  {
22104  int byteCount = Encoding.UTF8.GetByteCount(text);
22105  byte* utf8Bytes = (byte*) Marshal.AllocHGlobal(byteCount + 1);
22106  Util.GetUtf8(text, utf8Bytes, byteCount);
22107  utf8Bytes[byteCount] = 0; // Null-terminate the string
22108  return utf8Bytes;
22109  }
22110 
22111 
22118  private static byte* GetUtf8Bytes(string text, uint maxLength)
22119  {
22120  int byteCount = Encoding.UTF8.GetByteCount(text);
22121  int inputBufSize = Math.Max((int) maxLength + 1, byteCount + 1);
22122  byte[] utf8BytesArray = new byte[inputBufSize];
22123 
22124  fixed (byte* utf8Bytes = utf8BytesArray)
22125  {
22126  Util.GetUtf8(text, utf8Bytes, inputBufSize);
22127  Unsafe.InitBlockUnaligned(utf8Bytes, 0, (uint) inputBufSize);
22128 
22129  byte* result = (byte*) Marshal.AllocHGlobal(inputBufSize);
22130  Buffer.MemoryCopy(utf8Bytes, result, inputBufSize, inputBufSize);
22131 
22132  return result;
22133  }
22134  }
22135 
22136 
22143  private static bool AreUtf8StringsEqual(byte* utf8Bytes, string text)
22144  {
22145  int byteCount = Encoding.UTF8.GetByteCount(text);
22146  return Util.AreStringsEqual(utf8Bytes, byteCount, utf8Bytes);
22147  }
22148 
22154  private static string GetStringFromUtf8(byte* utf8Bytes) => Util.StringFromPtr(utf8Bytes);
22155 
22160  private static void FreeUtf8Bytes(byte* utf8Bytes)
22161  {
22162  int allocatedSize = GetUtf8BytesLength(utf8Bytes);
22163  if (allocatedSize > Util.StackAllocationSizeLimit)
22164  {
22165  Util.Free(utf8Bytes);
22166  }
22167  }
22168 
22174  private static int GetUtf8BytesLength(byte* utf8Bytes)
22175  {
22176  if (utf8Bytes == null)
22177  {
22178  return 0;
22179  }
22180 
22181  int length = 0;
22182  while (*(utf8Bytes + length) != 0)
22183  {
22184  length++;
22185  }
22186 
22187  return length;
22188  }
22189 
22190 
22196  public static Vector2F CalcTextSize(string text)
22197  => CalcTextSizeImpl(text);
22198 
22205  public static Vector2F CalcTextSize(string text, int start)
22206  => CalcTextSizeImpl(text, start);
22207 
22214  public static Vector2F CalcTextSize(string text, float wrapWidth)
22215  => CalcTextSizeImpl(text, wrapWidth: wrapWidth);
22216 
22223  public static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash)
22224  => CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22225 
22233  public static Vector2F CalcTextSize(string text, int start, int length)
22234  => CalcTextSizeImpl(text, start, length);
22235 
22243  public static Vector2F CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
22244  => CalcTextSizeImpl(text, start, hideTextAfterDoubleHash: hideTextAfterDoubleHash);
22245 
22253  public static Vector2F CalcTextSize(string text, int start, float wrapWidth)
22254  => CalcTextSizeImpl(text, start, wrapWidth: wrapWidth);
22255 
22263  public static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash, float wrapWidth)
22264  => CalcTextSizeImpl(text, hideTextAfterDoubleHash: hideTextAfterDoubleHash, wrapWidth: wrapWidth);
22265 
22274  public static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
22275  => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
22276 
22285  public static Vector2F CalcTextSize(string text, int start, int length, float wrapWidth)
22286  => CalcTextSizeImpl(text, start, length, wrapWidth: wrapWidth);
22287 
22297  public static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
22298  => CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
22299 
22309  private static Vector2F CalcTextSizeImpl(
22310  string text,
22311  int start = 0,
22312  int? length = null,
22313  bool hideTextAfterDoubleHash = false,
22314  float wrapWidth = -1.0f)
22315  {
22316  Vector2F ret;
22317  byte* nativeTextStart = null;
22318  byte* nativeTextEnd = null;
22319  int textByteCount = 0;
22320  if (text != null)
22321  {
22322  int textToCopyLen = length.HasValue ? length.Value : text.Length;
22323  textByteCount = Util.CalcSizeInUtf8(text, start, textToCopyLen);
22324  if (textByteCount > Util.StackAllocationSizeLimit)
22325  {
22326  nativeTextStart = Util.Allocate(textByteCount + 1);
22327  }
22328  else
22329  {
22330  byte* nativeTextStackBytes = stackalloc byte[textByteCount + 1];
22331  nativeTextStart = nativeTextStackBytes;
22332  }
22333 
22334  int nativeTextOffset = Util.GetUtf8(text, start, textToCopyLen, nativeTextStart, textByteCount);
22335  nativeTextStart[nativeTextOffset] = 0;
22336  nativeTextEnd = nativeTextStart + nativeTextOffset;
22337  }
22338 
22339  ImGuiNative.igCalcTextSize(&ret, nativeTextStart, nativeTextEnd, *(byte*) &hideTextAfterDoubleHash, wrapWidth);
22340  if (textByteCount > Util.StackAllocationSizeLimit)
22341  {
22342  Util.Free(nativeTextStart);
22343  }
22344 
22345  return ret;
22346  }
22347 
22355  public static bool InputText(
22356  string label,
22357  IntPtr buf,
22358  uint bufSize)
22359  => InputText(label, buf, bufSize, 0, null, IntPtr.Zero);
22360 
22369  public static bool InputText(
22370  string label,
22371  IntPtr buf,
22372  uint bufSize,
22373  ImGuiInputTexts flag)
22374  => InputText(label, buf, bufSize, flag, null, IntPtr.Zero);
22375 
22385  public static bool InputText(
22386  string label,
22387  IntPtr buf,
22388  uint bufSize,
22389  ImGuiInputTexts flag,
22390  ImGuiInputTextCallback callback)
22391  => InputText(label, buf, bufSize, flag, callback, IntPtr.Zero);
22392 
22403  public static bool InputText(
22404  string label,
22405  IntPtr buf,
22406  uint bufSize,
22407  ImGuiInputTexts flag,
22408  ImGuiInputTextCallback callback,
22409  IntPtr userData)
22410  {
22411  int utf8LabelByteCount = Encoding.UTF8.GetByteCount(label);
22412  byte* utf8LabelBytes;
22413  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
22414  {
22415  utf8LabelBytes = Util.Allocate(utf8LabelByteCount + 1);
22416  }
22417  else
22418  {
22419  byte* stackPtr = stackalloc byte[utf8LabelByteCount + 1];
22420  utf8LabelBytes = stackPtr;
22421  }
22422 
22423  Util.GetUtf8(label, utf8LabelBytes, utf8LabelByteCount);
22424 
22425  bool ret = ImGuiNative.igInputText(utf8LabelBytes, (byte*) buf.ToPointer(), bufSize, flag, callback, userData.ToPointer()) != 0;
22426 
22427  if (utf8LabelByteCount > Util.StackAllocationSizeLimit)
22428  {
22429  Util.Free(utf8LabelBytes);
22430  }
22431 
22432  return ret;
22433  }
22434 
22441  public static bool Begin(string name, ImGuiWindows flag)
22442  {
22443  int utf8NameByteCount = Encoding.UTF8.GetByteCount(name);
22444  byte* utf8NameBytes;
22445  if (utf8NameByteCount > Util.StackAllocationSizeLimit)
22446  {
22447  utf8NameBytes = Util.Allocate(utf8NameByteCount + 1);
22448  }
22449  else
22450  {
22451  byte* stackPtr = stackalloc byte[utf8NameByteCount + 1];
22452  utf8NameBytes = stackPtr;
22453  }
22454 
22455  Util.GetUtf8(name, utf8NameBytes, utf8NameByteCount);
22456 
22457  byte* pOpen = null;
22458  byte ret = ImGuiNative.igBegin(utf8NameBytes, pOpen, flag);
22459 
22460  if (utf8NameByteCount > Util.StackAllocationSizeLimit)
22461  {
22462  Util.Free(utf8NameBytes);
22463  }
22464 
22465  return ret != 0;
22466  }
22467 
22474  public static bool MenuItem(string label, bool enabled) => MenuItem(label, string.Empty, false, enabled);
22475  }
22476 }
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetBgColor
static void igTableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
Igs the table set bg color using the specified target
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 2
Definition: ImGui.cs:6318
Alis.Core.Graphic.ImGui.Structs.ImGuiPayloadPtr
The im gui payload ptr
Definition: ImGuiPayloadPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.SetWindowFontScale
static void SetWindowFontScale(float scale)
Sets the window font scale using the specified scale
Definition: ImGui.cs:16773
Alis.Core.Graphic.ImGui.ImGui.ColorEdit4
static bool ColorEdit4(string label, ref Vector4F col)
Describes whether color edit 4
Definition: ImGui.cs:2541
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNextColumn
static void igNextColumn()
Igs the next column
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseReleased_Nil
static byte igIsMouseReleased_Nil(ImGuiMouseButton button)
Igs the is mouse released nil using the specified button
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int range 2
Definition: ImGui.cs:7735
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast)
Describes whether input scalar n
Definition: ImGui.cs:12217
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int
Definition: ImGui.cs:6034
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowClass
static void SetNextWindowClass(ImGuiWindowClassPtr windowClass)
Sets the next window using the specified window class
Definition: ImGui.cs:16276
Alis.Core.Graphic.ImGui.ImGui.GetKeyName
static string GetKeyName(ImGuiKey key)
Gets the key name using the specified key
Definition: ImGui.cs:9375
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTable
static byte igBeginTable(byte *strId, int column, ImGuiTables flag, Vector2F outerSize, float innerWidth)
Igs the begin table using the specified str id
Alis.Core.Graphic.ImGui.ImGui.ColorEdit3
static bool ColorEdit3(string label, ref Vector3F col, ImGuiColorEdits flag)
Describes whether color edit 3
Definition: ImGui.cs:2498
Alis.Core.Aspect.Math.Vector.Vector4F
Vector4F is a struct represent a glsl vec4 value
Definition: Vector4F.cs:40
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowClass
static void igSetNextWindowClass(ImGuiWindowClass *windowClass)
Igs the set next window using the specified window class
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChild_ID
static byte igBeginChild_ID(uint id, Vector2F size, byte border, ImGuiWindows flag)
Igs the begin child id using the specified id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDrawList
static ImDrawList * igGetWindowDrawList()
Igs the get window draw list
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowContentRegionMax
static void igGetWindowContentRegionMax(Vector2F *pOut)
Igs the get window content region max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetColumnWidth
static float GetColumnWidth(int columnIndex)
Gets the column width using the specified column index
Definition: ImGui.cs:9051
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
Describes whether v slider scalar
Definition: ImGui.cs:21610
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether slider int 3
Definition: ImGui.cs:18971
Alis.Core.Graphic.ImGui.ImGui.StyleColorsDark
static void StyleColorsDark(ImGuiStylePtr dst)
Styles the colors dark using the specified dst
Definition: ImGui.cs:19734
Alis.Core.Graphic.ImGui.ImGui.BeginMenu
static bool BeginMenu(string label)
Describes whether begin menu
Definition: ImGui.cs:850
Alis.Core.Graphic.ImGui.ImGui.IsItemVisible
static bool IsItemVisible()
Describes whether is item visible
Definition: ImGui.cs:12650
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(Vector2F pos)
Sets the window pos using the specified pos
Definition: ImGui.cs:16782
Alis.Core.Graphic.ImGui.ImGui.SetNextFrameWantCaptureMouse
static void SetNextFrameWantCaptureMouse(bool wantCaptureMouse)
Sets the next frame want capture mouse using the specified want capture mouse
Definition: ImGui.cs:16226
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCombo_Str
static byte igCombo_Str(byte *label, int *currentItem, byte *itemsSeparatedByZeros, int popupMaxHeightInItems)
Igs the combo str using the specified label
Alis.Core.Graphic.ImGui.ImGui.EndTooltip
static void EndTooltip()
Ends the tooltip
Definition: ImGui.cs:8867
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed)
Describes whether drag int range 2
Definition: ImGui.cs:7516
Alis.Core.Graphic.ImGui.ImGui.GetWindowPos
static Vector2F GetWindowPos()
Gets the window pos
Definition: ImGui.cs:9694
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputText
static byte igInputText(byte *label, byte *buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback, void *userData)
Igs the input text using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetItemDefaultFocus
static void igSetItemDefaultFocus()
Igs the set item default focus
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData)
Describes whether drag scalar
Definition: ImGui.cs:8030
Alis.Core.Graphic.ImGui.ImGui.EndFrame
static void EndFrame()
Ends the frame
Definition: ImGui.cs:8787
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowViewport
static ImGuiViewport * igGetWindowViewport()
Igs the get window viewport
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemActive
static byte igIsAnyItemActive()
Igs the is any item active
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCalcTextSize
static void igCalcTextSize(Vector2F *pOut, byte *text, byte *textEnd, byte hideTextAfterDoubleHash, float wrapWidth)
Igs the calc text size using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputTextWithHint
static byte igInputTextWithHint(byte *label, byte *hint, byte *buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback, void *userData)
Igs the input text with hint using the specified label
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushTextWrapPos
static void igPushTextWrapPos(float wrapLocalPosX)
Igs the push text wrap pos using the specified wrap local pos x
Alis.Core.Graphic.ImGui.Utils.Util.Free
static void Free(byte *ptr)
Frees the ptr
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStyleSelector
static byte igShowStyleSelector(byte *label)
Igs the show style selector using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCombo_Str_arr
static byte igCombo_Str_arr(byte *label, int *currentItem, byte **items, int itemsCount, int popupMaxHeightInItems)
Igs the combo str arr using the specified label
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEdits flag, ref float refCol)
Describes whether color picker 4
Definition: ImGui.cs:2809
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v)
Describes whether drag int 4
Definition: ImGui.cs:7022
Alis.Core.Graphic.ImGui.ImGui.MemAlloc
static IntPtr MemAlloc(uint size)
Mems the alloc using the specified size
Definition: ImGui.cs:13491
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v, string format, ImGuiInputTexts flag)
Describes whether input float 2
Definition: ImGui.cs:10886
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick()
Opens the popup on item click
Definition: ImGui.cs:14030
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
Plots the lines using the specified label
Definition: ImGui.cs:14834
Alis.Core.Graphic.ImGui.ImGui.SetDragDropPayload
static bool SetDragDropPayload(string type, IntPtr data, uint sz, ImGuiCond cond)
Describes whether set drag drop payload
Definition: ImGui.cs:16134
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginListBox
static byte igBeginListBox(byte *label, Vector2F size)
Igs the begin list box using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStyleEditor
static void igShowStyleEditor(ImGuiStyle * @ref)
Alis.Core.Graphic.ImGui.ImGui.PushClipRect
static void PushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, bool intersectWithCurrentClipRect)
Pushes the clip rect using the specified clip rect min
Definition: ImGui.cs:15217
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodes flag, ImGuiWindowClassPtr windowClass)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3481
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetID_Ptr
static uint igGetID_Ptr(void *ptrId)
Igs the get id ptr using the specified ptr id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDockID
static uint igGetWindowDockID()
Igs the get window dock id
Alis.Core.Graphic.ImGui.ImGui.IsPopupOpen
static bool IsPopupOpen(string strId, ImGuiPopups flag)
Describes whether is popup open
Definition: ImGui.cs:12883
Alis.Core.Graphic.ImGui.ImGui.TableNextColumn
static bool TableNextColumn()
Describes whether table next column
Definition: ImGui.cs:19971
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col, ImGuiColorEdits flag)
Describes whether color picker 4
Definition: ImGui.cs:2763
Alis.Core.Graphic.ImGui.ImGui.GetStringFromUtf8
static string GetStringFromUtf8(byte *utf8Bytes)
Gets the string from utf 8 using the specified utf 8 bytes
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ref bool pOpen)
Describes whether begin
Definition: ImGui.cs:222
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetID_Str
static uint igGetID_Str(byte *strId)
Igs the get id str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format)
Describes whether input scalar n
Definition: ImGui.cs:12267
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSpacing
static void igSpacing()
Igs the spacing
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid(string strId)
Describes whether begin popup context void
Definition: ImGui.cs:1125
Alis.Core.Graphic.ImGui.ImGui.PopId
static void PopId()
Pops the id
Definition: ImGui.cs:15076
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyleColorName
static byte * igGetStyleColorName(ImGuiCol idx)
Igs the get style color name using the specified idx
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string label)
Describes whether tree node ex
Definition: ImGui.cs:20552
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta(ImGuiMouseButton button)
Gets the mouse drag delta using the specified button
Definition: ImGui.cs:9443
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3451
Alis.Core.Graphic.ImGui.ImGui.IsAnyMouseDown
static bool IsAnyMouseDown()
Describes whether is any mouse down
Definition: ImGui.cs:12526
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColumnWidth
static void igSetColumnWidth(int columnIndex, float width)
Igs the set column width using the specified column index
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextWindow
static byte igBeginPopupContextWindow(byte *strId, ImGuiPopups popups)
Igs the begin popup context window using the specified str id
Alis.Core.Graphic.ImGui.ImGui.GetDrawListSharedData
static IntPtr GetDrawListSharedData()
Gets the draw list shared data
Definition: ImGui.cs:9166
Alis.Core.Graphic.ImGui.ImGui.FindViewportByPlatformHandle
static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platformHandle)
Finds the viewport by platform handle using the specified platform handle
Definition: ImGui.cs:8888
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat2
static byte igInputFloat2(byte *label, Vector2F *v, byte *format, ImGuiInputTexts flag)
Igs the input float 2 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushClipRect
static void igPushClipRect(Vector2F clipRectMin, Vector2F clipRectMax, byte intersectWithCurrentClipRect)
Igs the push clip rect using the specified clip rect min
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemFocused
static bool IsAnyItemFocused()
Describes whether is any item focused
Definition: ImGui.cs:12506
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin)
Describes whether drag scalar
Definition: ImGui.cs:8126
Alis.Core.Graphic.ImGui.ImGui.BeginDisabled
static void BeginDisabled()
Begins the disabled
Definition: ImGui.cs:699
Alis.Core.Graphic.ImGui.ImGui.IsKeyDown
static bool IsKeyDown(ImGuiKey key)
Describes whether is key down
Definition: ImGui.cs:12661
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumns flag, float initWidthOrWeight)
Tables the setup column using the specified label
Definition: ImGui.cs:20135
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
Plots the histogram using the specified label
Definition: ImGui.cs:14213
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow(string strId, ImGuiPopups popups)
Describes whether begin popup context window
Definition: ImGui.cs:1258
Alis.Core.Graphic.ImGui.ImGui.IsWindowHovered
static bool IsWindowHovered()
Describes whether is window hovered
Definition: ImGui.cs:12996
Alis.Core.Graphic.ImGui.ImGui.BeginMenu
static bool BeginMenu(string label, bool enabled)
Describes whether begin menu
Definition: ImGui.cs:891
Alis.Core.Graphic.ImGui.Utils.Unsafe
Contains generic, low-level functionality for manipulating pointers.
Definition: Unsafe.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRender
static void igRender()
Igs the render
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size, bool border, ImGuiWindows flag)
Describes whether begin child
Definition: ImGui.cs:525
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt
static byte igInputInt(byte *label, int *v, int step, int stepFast, ImGuiInputTexts flag)
Igs the input int using the specified label
Alis.Core.Graphic.ImGui.Utils.Util.StackAllocationSizeLimit
const int StackAllocationSizeLimit
The stack allocation size limit
Definition: Util.cs:44
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextFrameWantCaptureMouse
static void igSetNextFrameWantCaptureMouse(byte wantCaptureMouse)
Igs the set next frame want capture mouse using the specified want capture mouse
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSaveIniSettingsToDisk
static void igSaveIniSettingsToDisk(byte *iniFilename)
Igs the save ini settings to disk using the specified ini filename
Alis.Core.Graphic.ImGui.Structs.ImGuiStyle
The im gui style
Definition: ImGuiStyle.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputDouble
static byte igInputDouble(byte *label, double *v, double step, double stepFast, byte *format, ImGuiInputTexts flag)
Igs the input double using the specified label
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast)
Describes whether input scalar
Definition: ImGui.cs:11921
Alis.Core.Graphic.ImGui.Structs.ImGuiStoragePtr.NativePtr
ImGuiStorage * NativePtr
Gets the value of the native ptr
Definition: ImGuiStoragePtr.cs:43
Alis.Core.Graphic.ImGui.ImGui.BeginCombo
static bool BeginCombo(string label, string previewValue, ImGuiCombos flag)
Describes whether begin combo
Definition: ImGui.cs:634
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowBgAlpha
static void SetNextWindowBgAlpha(float alpha)
Sets the next window bg alpha using the specified alpha
Definition: ImGui.cs:16267
Alis.Core.Graphic.ImGui.ImGui.GetWindowHeight
static float GetWindowHeight()
Gets the window height
Definition: ImGui.cs:9684
Alis.Core.Graphic.ImGui.ImGui.CreateContext
static IntPtr CreateContext(ImFontAtlasPtr sharedFontAtlas)
Creates the context using the specified shared font atlas
Definition: ImGui.cs:3262
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
Plots the histogram using the specified label
Definition: ImGui.cs:14441
Alis.Core.Graphic.ImGui.ImGui.EndChild
static void EndChild()
Ends the child
Definition: ImGui.cs:8739
Alis.Core.Graphic.ImGui.ImGui.GetWindowDrawList
static ImDrawListPtr GetWindowDrawList()
Gets the window draw list
Definition: ImGui.cs:9674
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemActive
static bool IsAnyItemActive()
Describes whether is any item active
Definition: ImGui.cs:12496
Alis.Core.Graphic.ImGui.ImGui.PushButtonRepeat
static void PushButtonRepeat(bool repeat)
Pushes the button repeat using the specified repeat
Definition: ImGui.cs:15205
Alis.Core.Graphic.ImGui.ImGui.InputInt3
static bool InputInt3(string label, ref int v)
Describes whether input int 3
Definition: ImGui.cs:11649
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat2
static byte igSliderFloat2(byte *label, Vector2F *v, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the slider float 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed)
Describes whether drag float 2
Definition: ImGui.cs:3983
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupModal
static byte igBeginPopupModal(byte *name, byte *pOpen, ImGuiWindows flag)
Igs the begin popup modal using the specified name
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 4
Definition: ImGui.cs:7294
Alis.Core.Graphic.ImGui.Structs.ImGuiViewport
The im gui viewport
Definition: ImGuiViewport.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetFontTexUvWhitePixel
static Vector2F GetFontTexUvWhitePixel()
Gets the font tex uv white pixel
Definition: ImGui.cs:9196
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnName_Int
static byte * igTableGetColumnName_Int(int columnN)
Igs the table get column name int using the specified column n
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
Plots the histogram using the specified label
Definition: ImGui.cs:14289
Alis.Core.Graphic.ImGui.ImGui.GetContentRegionMax
static Vector2F GetContentRegionMax()
Gets the content region max
Definition: ImGui.cs:9072
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v, string format)
Describes whether input float 2
Definition: ImGui.cs:10812
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetTabItemClosed
static void igSetTabItemClosed(byte *tabOrDockedWindowLabel)
Igs the set tab item closed using the specified tab or docked window label
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
Describes whether v slider scalar
Definition: ImGui.cs:21482
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step, int stepFast)
Describes whether input int
Definition: ImGui.cs:11471
Alis.Core.Graphic.ImGui.Structs.ImFontAtlasPtr.NativePtr
ImFontAtlas * NativePtr
Gets the value of the native ptr
Definition: ImFontAtlasPtr.cs:46
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v)
Describes whether drag int
Definition: ImGui.cs:5762
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin)
Describes whether drag float
Definition: ImGui.cs:3631
Alis.Core.Graphic.ImGui.ImGui.GetWindowViewport
static ImGuiViewportPtr GetWindowViewport()
Gets the window viewport
Definition: ImGui.cs:9716
Alis.Core.Graphic.ImGui.Utils.Util.GetUtf8
static int GetUtf8(string s, byte *utf8Bytes, int utf8ByteCount)
Gets the utf 8 using the specified s
Definition: Util.cs:128
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCollapsingHeader_TreeNodeFlags
static byte igCollapsingHeader_TreeNodeFlags(byte *label, ImGuiTreeNodes flag)
Igs the collapsing header tree node flags using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginCombo
static bool BeginCombo(string label, string previewValue)
Describes whether begin combo
Definition: ImGui.cs:564
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetIO
static ImGuiIo * igGetIO()
Igs the get io
Alis.Core.Graphic.ImGui.Structs.ImGuiIo
The im gui io
Definition: ImGuiIO.cs:40
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether drag float 2
Definition: ImGui.cs:4264
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToClipboard
static void igLogToClipboard(int autoOpenDepth)
Igs the log to clipboard using the specified auto open depth
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnOffset
static float igGetColumnOffset(int columnIndex)
Igs the get column offset using the specified column index
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushItemWidth
static void igPushItemWidth(float itemWidth)
Igs the push item width using the specified item width
Alis.Core.Graphic.ImGui.ImGui.GetScrollMaxY
static float GetScrollMaxY()
Gets the scroll max y
Definition: ImGui.cs:9510
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTexts flag, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text with hint
Definition: ImGui.cs:22062
Alis.Core.Graphic.ImGui.ImGui.EndTabItem
static void EndTabItem()
Ends the tab item
Definition: ImGui.cs:8851
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPos
static void igGetCursorPos(Vector2F *pOut)
Igs the get cursor pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPosY
static float igGetCursorPosY()
Igs the get cursor pos y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloatRange2
static byte igDragFloatRange2(byte *label, float *vCurrentMin, float *vCurrentMax, float vSpeed, float vMin, float vMax, byte *format, byte *formatMax, ImGuiSliders flag)
Igs the drag float range 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsMouseDragging
static bool IsMouseDragging(ImGuiMouseButton button, float lockThreshold)
Describes whether is mouse dragging
Definition: ImGui.cs:12768
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 3
Definition: ImGui.cs:6806
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToTTY
static void igLogToTTY(int autoOpenDepth)
Igs the log to tty using the specified auto open depth
Alis.Core.Graphic.ImGui.Enums.ImGuiDir
ImGuiDir
The im gui dir enum
Definition: ImGuiDir.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiViewportPtr.NativePtr
ImGuiViewport * NativePtr
Gets the value of the native ptr
Definition: ImGuiViewportPtr.cs:45
Alis.Core.Graphic.ImGui.ImGui.TextWrapped
static void TextWrapped(string fmt)
Texts the wrapped using the specified fmt
Definition: ImGui.cs:20367
Alis.Core.Graphic.ImGui.ImGui.GetWindowSize
static Vector2F GetWindowSize()
Gets the window size
Definition: ImGui.cs:9705
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorPicker3
static byte igColorPicker3(byte *label, Vector3F *col, ImGuiColorEdits flag)
Igs the color picker 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetId
static uint GetId(string strId)
Gets the id using the specified str id
Definition: ImGui.cs:9260
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 3
Definition: ImGui.cs:4607
Alis.Core.Graphic.ImGui.ImGui.GetKeyPressedAmount
static int GetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
Gets the key pressed amount using the specified key
Definition: ImGui.cs:9388
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyle
static ImGuiStyle * igGetStyle()
Igs the get style
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine()
Sames the line
Definition: ImGui.cs:15512
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndPopup
static void igEndPopup()
Igs the end popup
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step)
Describes whether input int
Definition: ImGui.cs:11424
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat4
static byte igSliderFloat4(byte *label, Vector4F *v, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the slider float 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsKeyPressed
static bool IsKeyPressed(ImGuiKey key, bool repeat)
Describes whether is key pressed
Definition: ImGui.cs:12685
Alis.Core.Graphic.ImGui.ImGui.GetItemRectSize
static Vector2F GetItemRectSize()
Gets the item rect size
Definition: ImGui.cs:9352
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPlotLines_FloatPtr
static void igPlotLines_FloatPtr(byte *label, float *values, int valuesCount, int valuesOffset, byte *overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Igs the plot lines float ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetWindowContentRegionMax
static Vector2F GetWindowContentRegionMax()
Gets the window content region max
Definition: ImGui.cs:9632
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetContentRegionMax
static void igGetContentRegionMax(Vector2F *pOut)
Igs the get content region max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count)
Columnses the count
Definition: ImGui.cs:2864
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax)
Describes whether slider float 2
Definition: ImGui.cs:17748
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnName
static string TableGetColumnName(int columnN)
Tables the get column name using the specified column n
Definition: ImGui.cs:19897
Alis.Core.Graphic.ImGui.ImGui.ShowStyleSelector
static bool ShowStyleSelector(string label)
Describes whether show style selector
Definition: ImGui.cs:17134
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat4
static byte igInputFloat4(byte *label, Vector4F *v, byte *format, ImGuiInputTexts flag)
Igs the input float 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetColumnsCount
static int GetColumnsCount()
Gets the columns count
Definition: ImGui.cs:9029
Alis.Core.Graphic.ImGui.ImGui.PopFont
static void PopFont()
Pops the font
Definition: ImGui.cs:15068
Alis.Core.Graphic.ImGui.ImGui.TreePush
static void TreePush(IntPtr ptrId)
Trees the push using the specified ptr id
Definition: ImGui.cs:20786
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToMemory
static string SaveIniSettingsToMemory()
Saves the ini settings to memory
Definition: ImGui.cs:15579
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowContentSize
static void igSetNextWindowContentSize(Vector2F size)
Igs the set next window content size using the specified size
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset)
Plots the lines using the specified label
Definition: ImGui.cs:14634
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(string label)
Describes whether tree node
Definition: ImGui.cs:20404
Alis.Core.Graphic.ImGui.ImGui.GetCursorPosY
static float GetCursorPosY()
Gets the cursor pos y
Definition: ImGui.cs:9114
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igResetMouseDragDelta
static void igResetMouseDragDelta(ImGuiMouseButton button)
Igs the reset mouse drag delta using the specified button
Alis.Core.Graphic.ImGui.ImGui.GetIo
static ImGuiIoPtr GetIo()
Gets the io
Definition: ImGui.cs:9310
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast, string format, ImGuiInputTexts flag)
Describes whether input float
Definition: ImGui.cs:10676
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTexts flag, ImGuiInputTextCallback callback)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDragDropTarget
static byte igBeginDragDropTarget()
Igs the begin drag drop target
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed)
Describes whether drag int
Definition: ImGui.cs:5830
Alis.Core.Graphic.ImGui.ImGui.Render
static void Render()
Renders
Definition: ImGui.cs:15453
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameCount
static int igGetFrameCount()
Igs the get frame count
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSelectable_Bool
static byte igSelectable_Bool(byte *label, byte selected, ImGuiSelectables flag, Vector2F size)
Igs the selectable bool using the specified label
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name)
Describes whether begin
Definition: ImGui.cs:180
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt
static byte igSliderInt(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the slider int using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether slider float
Definition: ImGui.cs:17675
Alis.Core.Graphic.ImGui.ImGui.SetTabItemClosed
static void SetTabItemClosed(string tabOrDockedWindowLabel)
Sets the tab item closed using the specified tab or docked window label
Definition: ImGui.cs:16557
Alis.Core.Graphic.ImGui.Utils.Unsafe.InitBlockUnaligned
static unsafe void InitBlockUnaligned(void *startAddress, byte value, uint byteCount)
Initializes a block of memory at the given location with a given initial value without assuming archi...
Definition: Unsafe.cs:85
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault(IntPtr platformRenderArg, IntPtr rendererRenderArg)
Renders the platform windows default using the specified platform render arg
Definition: ImGui.cs:15484
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax)
Describes whether drag float
Definition: ImGui.cs:3699
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_Ptr
static byte igTreeNode_Ptr(void *ptrId, byte *fmt)
Igs the tree node ptr using the specified ptr id
Alis.Core.Graphic.ImGui.Structs.ImGuiPlatformIoPtr
The im gui platform io ptr
Definition: ImGuiPlatformIOPtr.cs:39
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTexts flag)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnIndex
static int igGetColumnIndex()
Igs the get column index
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin)
Describes whether drag float 3
Definition: ImGui.cs:4471
Alis.Core.Graphic.ImGui.ImGui.TreePush
static void TreePush(string strId)
Trees the push using the specified str id
Definition: ImGui.cs:20750
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v)
Describes whether drag float 4
Definition: ImGui.cs:4755
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFocus_Str
static void igSetWindowFocus_Str(byte *name)
Igs the set window focus str using the specified name
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether slider float 2
Definition: ImGui.cs:17891
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 2
Definition: ImGui.cs:18679
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format)
Describes whether v slider float
Definition: ImGui.cs:21111
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosY
static void SetScrollFromPosY(float localY, float centerYRatio)
Sets the scroll from pos y using the specified local y
Definition: ImGui.cs:16484
Alis.Core.Graphic.ImGui.Enums.ImGuiHovereds
ImGuiHovereds
The im gui hovered flags enum
Definition: ImGuiHovereds.cs:39
Alis.Core.Graphic.ImGui.ImGui.VSliderScalar
static bool VSliderScalar(string label, Vector2F size, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
Describes whether v slider scalar
Definition: ImGui.cs:21532
Alis.Core.Graphic.ImGui.ImGui.ShowUserGuide
static void ShowUserGuide()
Shows the user guide
Definition: ImGui.cs:17171
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin)
Describes whether drag float 4
Definition: ImGui.cs:4891
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTexts flag)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_StrStr
static byte igTreeNode_StrStr(byte *strId, byte *fmt)
Igs the tree node str str using the specified str id
Alis.Core.Aspect
Definition: AlisObject.cs:33
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowPos
static void igSetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
Igs the set next window pos using the specified pos
Alis.Core.Graphic.ImGui.ImGui.SetItemDefaultFocus
static void SetItemDefaultFocus()
Sets the item default focus
Definition: ImGui.cs:16180
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogFinish
static void igLogFinish()
Igs the log finish
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat2
static byte igDragFloat2(byte *label, Vector2F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the drag float 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.CheckboxFlags
static bool CheckboxFlags(string label, ref int flags, int flagsValue)
Describes whether checkbox flags
Definition: ImGui.cs:1996
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopClipRect
static void igPopClipRect()
Igs the pop clip rect
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether drag int 3
Definition: ImGui.cs:6951
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBulletText
static void igBulletText(byte *fmt)
Igs the bullet text using the specified fmt
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDisabled
static void igBeginDisabled(byte disabled)
Igs the begin disabled using the specified disabled
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin)
Describes whether drag float 2
Definition: ImGui.cs:4051
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseClickedCount
static int igGetMouseClickedCount(ImGuiMouseButton button)
Igs the get mouse clicked count using the specified button
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextUnformatted
static void igTextUnformatted(byte *text, byte *textEnd)
Igs the text unformatted using the specified text
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault()
Renders the platform windows default
Definition: ImGui.cs:15461
Alis.Core.Graphic.ImGui.ImGui.ShowDebugLogWindow
static void ShowDebugLogWindow()
Shows the debug log window
Definition: ImGui.cs:16994
Alis.Core.Graphic.ImGui.ImGui.EndListBox
static void EndListBox()
Ends the list box
Definition: ImGui.cs:8803
Alis.Core.Graphic.ImGui.ImGui.IsMousePosValid
static bool IsMousePosValid()
Describes whether is mouse pos valid
Definition: ImGui.cs:12805
Alis.Core.Graphic.ImGui.ImGui.BeginTabBar
static bool BeginTabBar(string strId)
Describes whether begin tab bar
Definition: ImGui.cs:1426
Alis.Core.Graphic.ImGui.ImGui.CloseCurrentPopup
static void CloseCurrentPopup()
Closes the current popup
Definition: ImGui.cs:2080
Alis.Core.Graphic.ImGui.ImGui.PopClipRect
static void PopClipRect()
Pops the clip rect
Definition: ImGui.cs:15060
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size)
Describes whether image button
Definition: ImGui.cs:9809
Alis.Core.Graphic.ImGui.ImGui.UpdatePlatformWindows
static void UpdatePlatformWindows()
Updates the platform windows
Definition: ImGui.cs:20813
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport(ImGuiViewportPtr viewport, ImGuiDockNodes flag)
Docks the space over viewport using the specified viewport
Definition: ImGui.cs:3466
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(IntPtr ptrId, string fmt)
Describes whether tree node
Definition: ImGui.cs:20512
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorPosX
static float igGetCursorPosX()
Igs the get cursor pos x
Alis.Core.Graphic.ImGui.ImGui.PopStyleColor
static void PopStyleColor(int count)
Pops the style color using the specified count
Definition: ImGui.cs:15102
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnIndex
static int TableGetColumnIndex()
Tables the get column index
Definition: ImGui.cs:19875
Alis.Core.Graphic.ImGui.ImGui.ShowMetricsWindow
static void ShowMetricsWindow(ref bool pOpen)
Shows the metrics window using the specified p open
Definition: ImGui.cs:17082
Alis.Core.Graphic.ImGui.ImGui.GetCursorPos
static Vector2F GetCursorPos()
Gets the cursor pos
Definition: ImGui.cs:9093
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction, Vector2F sizeArg)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15157
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertHSVtoRGB
static void igColorConvertHSVtoRGB(float h, float s, float v, float *outR, float *outG, float *outB)
Igs the color convert hs vto rgb using the specified h
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0)
Describes whether image button
Definition: ImGui.cs:9855
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertU32ToFloat4
static void igColorConvertU32ToFloat4(Vector4F *pOut, uint @in)
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowBgAlpha
static void igSetNextWindowBgAlpha(float alpha)
Igs the set next window bg alpha using the specified alpha
Alis.Core.Graphic.ImGui.ImGui.MemFree
static void MemFree(IntPtr ptr)
Mems the free using the specified ptr
Definition: ImGui.cs:13501
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRadioButton_Bool
static byte igRadioButton_Bool(byte *label, byte active)
Igs the radio button bool using the specified label
Alis.Core.Graphic.ImGui.ImGui.LogButtons
static void LogButtons()
Logs the buttons
Definition: ImGui.cs:13344
Alis.Core.Graphic.ImGui.ImGui.TableSetColumnIndex
static bool TableSetColumnIndex(int columnN)
Describes whether table set column index
Definition: ImGui.cs:20045
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat3
static byte igInputFloat3(byte *label, Vector3F *v, byte *format, ImGuiInputTexts flag)
Igs the input float 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick(string strId)
Opens the popup on item click using the specified str id
Definition: ImGui.cs:14041
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowDockId
static void SetNextWindowDockId(uint dockId)
Sets the next window dock id using the specified dock id
Definition: ImGui.cs:16317
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollMaxX
static float igGetScrollMaxX()
Igs the get scroll max x
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIndent
static void igIndent(float indentW)
Igs the indent using the specified indent w
Alis.Core.Graphic.ImGui.ImGui.SetWindowFocus
static void SetWindowFocus(string name)
Sets the window focus using the specified name
Definition: ImGui.cs:16737
Alis.Core.Graphic.ImGui.Delegates
Definition: ImGuiInputTextCallback.cs:34
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(uint id)
Opens the popup using the specified id
Definition: ImGui.cs:14011
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Plots the lines using the specified label
Definition: ImGui.cs:14986
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClass
The im gui window
Definition: ImGuiWindowClass.cs:38
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt2
static byte igSliderInt2(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the slider int 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.Unindent
static void Unindent(float indentW)
Unindents the indent w
Definition: ImGui.cs:20805
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsRectVisible_Nil
static byte igIsRectVisible_Nil(Vector2F size)
Igs the is rect visible nil using the specified size
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat3
static byte igSliderFloat3(byte *label, Vector3F *v, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the slider float 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowScroll
static void SetNextWindowScroll(Vector2F scroll)
Sets the next window scroll using the specified scroll
Definition: ImGui.cs:16378
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPosX
static void igSetCursorPosX(float localX)
Igs the set cursor pos x using the specified local x
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetStateStorage
static void igSetStateStorage(ImGuiStorage *storage)
Igs the set state storage using the specified storage
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat4
static byte igDragFloat4(byte *label, Vector4F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the drag float 4 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPos
static void igSetCursorPos(Vector2F localPos)
Igs the set cursor pos using the specified local pos
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDisabled
static void igEndDisabled()
Igs the end disabled
Alis.Core.Graphic.ImGui.ImGui.NewFrame
static void NewFrame()
News the frame
Definition: ImGui.cs:13912
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromMemory
static void LoadIniSettingsFromMemory(string iniData)
Loads the ini settings from memory using the specified ini data
Definition: ImGui.cs:13271
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name, ref bool pOpen, ImGuiWindows flag)
Describes whether begin popup modal
Definition: ImGui.cs:1384
Alis.Core.Graphic.ImGui.ImGui.GetUtf8Bytes
static byte * GetUtf8Bytes(string text, uint maxLength)
Gets the utf 8 bytes using the specified text
Definition: ImGui.cs:22118
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos, ImGuiCond cond, Vector2F pivot)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16369
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTexts flag, ImGuiInputTextCallback callback, IntPtr userData)
Determines whether the input text.
Definition: ImGui.cs:21818
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowSizeConstraints
static void igSetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, void *customCallbackData)
Igs the set next window size constraints using the specified size min
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
Describes whether drag scalar n
Definition: ImGui.cs:8654
Alis.Core.Graphic.ImGui.ImGui.GetCursorPosX
static float GetCursorPosX()
Gets the cursor pos x
Definition: ImGui.cs:9104
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size, bool border)
Describes whether begin child
Definition: ImGui.cs:509
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether v slider float
Definition: ImGui.cs:21188
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMemFree
static void igMemFree(void *ptr)
Igs the mem free using the specified ptr
Alis.Core.Graphic.ImGui.ImGui.GetWindowWidth
static float GetWindowWidth()
Gets the window width
Definition: ImGui.cs:9726
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Float
static void igValue_Float(byte *prefix, float v, byte *floatFormat)
Igs the value float using the specified prefix
Alis.Core.Graphic.ImGui.ImGui.IsMousePosValid
static bool IsMousePosValid(ref Vector2F mousePos)
Describes whether is mouse pos valid
Definition: ImGui.cs:12817
Alis.Core.Graphic.ImGui.ImGui.FindViewportById
static ImGuiViewportPtr FindViewportById(uint id)
Finds the viewport by id using the specified id
Definition: ImGui.cs:8877
Alis.Core.Graphic.ImGui.ImGui.Bullet
static void Bullet()
Bullets
Definition: ImGui.cs:1815
Alis.Core.Graphic.ImGui.ImGui.DebugCheckVersionAndDataLayout
static bool DebugCheckVersionAndDataLayout(string versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
Describes whether debug check version and data layout
Definition: ImGui.cs:3280
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v, string format)
Describes whether input float 4
Definition: ImGui.cs:11232
Alis.Core.Graphic.ImGui.ImGui.EndPopup
static void EndPopup()
Ends the popup
Definition: ImGui.cs:8835
Alis.Core.Graphic.ImGui.ImGui.SliderFloat2
static bool SliderFloat2(string label, ref Vector2F v, float vMin, float vMax, string format)
Describes whether slider float 2
Definition: ImGui.cs:17815
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(string name, Vector2F pos, ImGuiCond cond)
Sets the window pos using the specified name
Definition: ImGui.cs:16842
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.Unindent
static void Unindent()
Unindents
Definition: ImGui.cs:20795
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether v slider int
Definition: ImGui.cs:21407
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndFrame
static void igEndFrame()
Igs the end frame
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyPressedAmount
static int igGetKeyPressedAmount(ImGuiKey key, float repeatDelay, float rate)
Igs the get key pressed amount using the specified key
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleVar_Vec2
static void igPushStyleVar_Vec2(ImGuiStyleVar idx, Vector2F val)
Igs the push style var vec 2 using the specified idx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemClicked
static byte igIsItemClicked(ImGuiMouseButton mouseButton)
Igs the is item clicked using the specified mouse button
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed)
Describes whether drag scalar n
Definition: ImGui.cs:8425
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnName
static string TableGetColumnName()
Tables the get column name
Definition: ImGui.cs:19885
Alis.Core.Graphic.ImGui.Enums.ImGuiTableBgTarget
ImGuiTableBgTarget
The im gui table bg target enum
Definition: ImGuiTableBgTarget.cs:36
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowDockId
static void SetNextWindowDockId(uint dockId, ImGuiCond cond)
Sets the next window dock id using the specified dock id
Definition: ImGui.cs:16328
Alis.Core.Graphic.ImGui.ImGui.GetItemRectMin
static Vector2F GetItemRectMin()
Gets the item rect min
Definition: ImGui.cs:9341
Alis.Core.Graphic.ImGui.ImGui.ArrowButton
static bool ArrowButton(string strId, ImGuiDir dir)
Describes whether arrow button
Definition: ImGui.cs:141
Alis.Core.Graphic.ImGui.ImGui.LogToTty
static void LogToTty()
Logs the to tty
Definition: ImGui.cs:13471
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ImGuiTreeNodes flag)
Describes whether collapsing header
Definition: ImGui.cs:2131
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize)
Plots the lines using the specified label
Definition: ImGui.cs:14910
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, int v)
Values the prefix
Definition: ImGui.cs:20861
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseClicked_Bool
static byte igIsMouseClicked_Bool(ImGuiMouseButton button, byte repeat)
Igs the is mouse clicked bool using the specified button
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether drag int
Definition: ImGui.cs:6111
Alis.Core.Graphic.ImGui.ImGui.ListBox
static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount, int heightInItems)
Describes whether list box
Definition: ImGui.cs:13164
Alis.Core.Graphic.ImGui.ImGui.GetClipboardText
static string GetClipboardText()
Gets the clipboard text
Definition: ImGui.cs:8941
Alis.Core.Graphic.ImGui.ImGui.PopTextWrapPos
static void PopTextWrapPos()
Pops the text wrap pos
Definition: ImGui.cs:15136
Alis.Core.Graphic.ImGui.Structs.ImGuiPayload
The im gui payload
Definition: ImGuiPayload.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igImage
static void igImage(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
Igs the image using the specified user texture id
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed)
Describes whether drag float 3
Definition: ImGui.cs:4403
Alis.Core.Graphic.ImGui.ImGui.IsMouseDragging
static bool IsMouseDragging(ImGuiMouseButton button)
Describes whether is mouse dragging
Definition: ImGui.cs:12755
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros)
Describes whether combo
Definition: ImGui.cs:3107
Alis.Core.Graphic.ImGui.ImGui.GetColumnOffset
static float GetColumnOffset(int columnIndex)
Gets the column offset using the specified column index
Definition: ImGui.cs:9019
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderInt
static byte igVSliderInt(byte *label, Vector2F size, int *v, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the v slider int using the specified label
Alis.Core.Graphic.ImGui.ImGui.TextUnformatted
static void TextUnformatted(string text)
Texts the unformatted using the specified text
Definition: ImGui.cs:20330
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns()
Columnses
Definition: ImGui.cs:2852
Alis.Core.Graphic.ImGui.ImGui.SeparatorText
static void SeparatorText(string label)
Separators the text using the specified label
Definition: ImGui.cs:15918
Alis.Core.Graphic.ImGui.ImGui.IsMouseClicked
static bool IsMouseClicked(ImGuiMouseButton button)
Describes whether is mouse clicked
Definition: ImGui.cs:12708
Alis.Core.Graphic.ImGui.ImGui.EndMenu
static void EndMenu()
Ends the menu
Definition: ImGui.cs:8819
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, float v)
Values the prefix
Definition: ImGui.cs:20935
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollFromPosY_Float
static void igSetScrollFromPosY_Float(float localY, float centerYRatio)
Igs the set scroll from pos y float using the specified local y
Alis.Core.Graphic.ImGui.ImGui.ColorPicker3
static bool ColorPicker3(string label, ref Vector3F col, ImGuiColorEdits flag)
Describes whether color picker 3
Definition: ImGui.cs:2674
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsRectVisible_Vec2
static byte igIsRectVisible_Vec2(Vector2F rectMin, Vector2F rectMax)
Igs the is rect visible vec 2 using the specified rect min
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, bool enabled)
Describes whether menu item
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorPosY
static void igSetCursorPosY(float localY)
Igs the set cursor pos y using the specified local y
Alis.Core.Graphic.ImGui.Enums.ImGuiSelectables
ImGuiSelectables
The im gui selectable flags enum
Definition: ImGuiSelectables.cs:39
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax, ImGuiSliders flag)
Describes whether drag int range 2
Definition: ImGui.cs:7927
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropTarget
static bool BeginDragDropTarget()
Describes whether begin drag drop target
Definition: ImGui.cs:741
Alis.Core.Graphic.ImGui.ImGui.FreeUtf8Bytes
static void FreeUtf8Bytes(byte *utf8Bytes)
Frees the utf 8 bytes using the specified utf 8 bytes
Definition: ImGui.cs:22160
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax)
Plots the histogram using the specified label
Definition: ImGui.cs:14365
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowContentSize
static void SetNextWindowContentSize(Vector2F size)
Sets the next window content size using the specified size
Definition: ImGui.cs:16308
Alis.Core.Graphic.ImGui.ImGui.IsItemActive
static bool IsItemActive()
Describes whether is item active
Definition: ImGui.cs:12546
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16421
Alis.Core.Graphic.ImGui.ImGui.SetColorEditOptions
static void SetColorEditOptions(ImGuiColorEdits flag)
Sets the color edit options using the specified flags
Definition: ImGui.cs:16013
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether slider int 2
Definition: ImGui.cs:18755
Alis.Core.Graphic.ImGui.ImGui.ColorConvertRgBtoHsv
static void ColorConvertRgBtoHsv(float r, float g, float b, out float outH, out float outS, out float outV)
Colors the convert rg bto hsv using the specified r
Definition: ImGui.cs:2421
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float
Definition: ImGui.cs:3767
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected)
Describes whether selectable
Definition: ImGui.cs:15648
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDown_Nil
static byte igIsMouseDown_Nil(ImGuiMouseButton button)
Igs the is mouse down nil using the specified button
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether slider int 4
Definition: ImGui.cs:19187
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text
Definition: ImGui.cs:21730
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderFloat
static byte igSliderFloat(byte *label, float *v, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the slider float using the specified label
Alis.Core.Graphic.ImGui.ImGui.IsItemFocused
static bool IsItemFocused()
Describes whether is item focused
Definition: ImGui.cs:12608
Alis.Core.Graphic.ImGui.ImGui.IsMouseDown
static bool IsMouseDown(ImGuiMouseButton button)
Describes whether is mouse down
Definition: ImGui.cs:12744
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax)
Describes whether slider int 3
Definition: ImGui.cs:18828
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTabBar
static void igEndTabBar()
Igs the end tab bar
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step)
Describes whether input float
Definition: ImGui.cs:10466
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectSize
static void igGetItemRectSize(Vector2F *pOut)
Igs the get item rect size using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetMouseCursor
static ImGuiMouseCursor GetMouseCursor()
Gets the mouse cursor
Definition: ImGui.cs:9419
Alis.Core.Graphic.ImGui.ImGui.Spacing
static void Spacing()
Spacings
Definition: ImGui.cs:19697
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Int
static void igValue_Int(byte *prefix, int v)
Igs the value int using the specified prefix
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemActive
static byte igIsItemActive()
Igs the is item active
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 4
Definition: ImGui.cs:7158
Alis.Core.Graphic.ImGui.ImGui.PushItemWidth
static void PushItemWidth(float itemWidth)
Pushes the item width using the specified item width
Definition: ImGui.cs:15292
Alis.Core.Graphic.ImGui.ImGui.AreByteArraysEqual
static bool AreByteArraysEqual(byte[] array1, byte[] array2)
Describes whether are byte arrays equal
Definition: ImGui.cs:21979
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int
Definition: ImGui.cs:18463
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTime
static double igGetTime()
Igs the get time
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextWrapped
static void igTextWrapped(byte *fmt)
Igs the text wrapped using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(uint col)
Gets the color u 32 using the specified col
Definition: ImGui.cs:8987
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowPos_Str
static void igSetWindowPos_Str(byte *name, Vector2F pos, ImGuiCond cond)
Igs the set window pos str using the specified name
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count, string id, bool border)
Columnses the count
Definition: ImGui.cs:2915
Alis.Core.Graphic.ImGui.ImGui.TreePop
static void TreePop()
Trees the pop
Definition: ImGui.cs:20741
Alis.Core.Graphic.ImGui.ImGui.RadioButton
static bool RadioButton(string label, bool active)
Describes whether radio button
Definition: ImGui.cs:15371
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsPopupOpen_Str
static byte igIsPopupOpen_Str(byte *strId, ImGuiPopups flag)
Igs the is popup open str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast, string format)
Describes whether input double
Definition: ImGui.cs:10252
Alis.Core.Graphic.ImGui.ImGui.SetColumnWidth
static void SetColumnWidth(int columnIndex, float width)
Sets the column width using the specified column index
Definition: ImGui.cs:16033
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta()
Gets the mouse drag delta
Definition: ImGui.cs:9429
Alis.Core.Graphic.ImGui.ImGui.RadioButton
static bool RadioButton(string label, ref int v, int vButton)
Describes whether radio button
Definition: ImGui.cs:15413
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int
Definition: ImGui.cs:5966
Alis.Core.Graphic.ImGui.ImGui.DestroyPlatformWindows
static void DestroyPlatformWindows()
Destroys the platform windows
Definition: ImGui.cs:3371
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos, ImGuiCond cond)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16357
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(string name, Vector2F size)
Sets the window size using the specified name
Definition: ImGui.cs:16899
Alis.Core.Graphic.ImGui.ImGui.IsItemDeactivated
static bool IsItemDeactivated()
Describes whether is item deactivated
Definition: ImGui.cs:12578
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.DebugTextEncoding
static void DebugTextEncoding(string text)
Debugs the text encoding using the specified text
Definition: ImGui.cs:3318
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowScroll
static void igSetNextWindowScroll(Vector2F scroll)
Igs the set next window scroll using the specified scroll
Alis.Core
Definition: AudioClip.cs:35
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt4
static byte igSliderInt4(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the slider int 4 using the specified label
Alis.Core.Graphic.ImGui.Enums.ImGuiCol
ImGuiCol
The im gui col enum
Definition: ImGuiCol.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleVar_Float
static void igPushStyleVar_Float(ImGuiStyleVar idx, float val)
Igs the push style var float using the specified idx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopStyleColor
static void igPopStyleColor(int count)
Igs the pop style color using the specified count
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogButtons
static void igLogButtons()
Igs the log buttons
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowDebugLogWindow
static void igShowDebugLogWindow(byte *pOpen)
Igs the show debug log window using the specified p open
Alis.Core.Graphic.ImGui.ImGui.BeginListBox
static bool BeginListBox(string label, Vector2F size)
Describes whether begin list box
Definition: ImGui.cs:801
Alis.Core.Graphic.ImGui.ImGui.SetDragDropPayload
static bool SetDragDropPayload(string type, IntPtr data, uint sz)
Describes whether set drag drop payload
Definition: ImGui.cs:16090
Alis.Core.Graphic.ImGui.ImGui.EndChildFrame
static void EndChildFrame()
Ends the child frame
Definition: ImGui.cs:8747
Alis.Core.Graphic.ImGui.Structs.ImGuiPlatformIo
The im gui platform io
Definition: ImGuiPlatformIO.cs:38
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectMin
static void igGetItemRectMin(Vector2F *pOut)
Igs the get item rect min using the specified p out
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether slider int
Definition: ImGui.cs:18539
Alis.Core.Graphic.ImGui.ImGui.IsKeyReleased
static bool IsKeyReleased(ImGuiKey key)
Describes whether is key released
Definition: ImGui.cs:12697
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_Vec4
static uint igGetColorU32_Vec4(Vector4F col)
Igs the get color u 32 vec 4 using the specified col
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt
static byte igDragInt(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the drag int using the specified label
Alis.Core.Graphic.ImGui.Enums.ImGuiKey
ImGuiKey
The im gui key enum
Definition: ImGuiKey.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopID
static void igPopID()
Igs the pop id
Alis.Core.Graphic.ImGui.ImGui.GetWindowDpiScale
static float GetWindowDpiScale()
Gets the window dpi scale
Definition: ImGui.cs:9664
Alis.Core.Graphic.ImGui.ImGui.Button
static bool Button(string label, Vector2F size)
Describes whether button
Definition: ImGui.cs:1902
Alis.Core.Graphic.ImGui.ImGui.BeginMenuBar
static bool BeginMenuBar()
Describes whether begin menu bar
Definition: ImGui.cs:930
Alis.Core.Graphic.ImGui.ImGui.DockSpaceOverViewport
static uint DockSpaceOverViewport()
Docks the space over viewport
Definition: ImGui.cs:3437
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string itemsSeparatedByZeros, int popupMaxHeightInItems)
Describes whether combo
Definition: ImGui.cs:3181
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string[] items, int itemsCount, int popupMaxHeightInItems)
Describes whether combo
Definition: ImGui.cs:3033
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImDrawListPtr
The im draw list ptr
Definition: ImDrawListPtr.cs:42
Alis.Core.Graphic.ImGui.ImGui.SetStateStorage
static void SetStateStorage(ImGuiStoragePtr storage)
Sets the state storage using the specified storage
Definition: ImGui.cs:16547
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size, bool border, ImGuiWindows flag)
Describes whether begin child
Definition: ImGui.cs:439
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowAboutWindow
static void igShowAboutWindow(byte *pOpen)
Igs the show about window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowContentRegionMin
static void igGetWindowContentRegionMin(Vector2F *pOut)
Igs the get window content region min using the specified p out
Alis.Core.Graphic.ImGui.ImGui.GetMouseClickedCount
static int GetMouseClickedCount(ImGuiMouseButton button)
Gets the mouse clicked count using the specified button
Definition: ImGui.cs:9409
Alis.Core.Graphic.ImGui.ImGui.SetKeyboardFocusHere
static void SetKeyboardFocusHere()
Sets the keyboard focus here
Definition: ImGui.cs:16188
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropSource
static bool BeginDragDropSource(ImGuiDragDrops flag)
Describes whether begin drag drop source
Definition: ImGui.cs:731
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(Vector2F size)
Sets the window size using the specified size
Definition: ImGui.cs:16878
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step)
Describes whether input double
Definition: ImGui.cs:10118
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax)
Describes whether slider int 4
Definition: ImGui.cs:19044
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndChild
static void igEndChild()
Igs the end child
Alis.Core.Graphic.ImGui.ImGui.SetCursorPosY
static void SetCursorPosY(float localY)
Sets the cursor pos y using the specified local y
Definition: ImGui.cs:16069
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected, ImGuiSelectables flag, Vector2F size)
Describes whether selectable
Definition: ImGui.cs:15736
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(ImGuiCol idx)
Gets the color u 32 using the specified idx
Definition: ImGui.cs:8952
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast, string format)
Describes whether input float
Definition: ImGui.cs:10600
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v)
Describes whether drag float 2
Definition: ImGui.cs:3915
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopButtonRepeat
static void igPopButtonRepeat()
Igs the pop button repeat
Alis.Core.Graphic.ImGui.ImGui.GetFrameHeightWithSpacing
static float GetFrameHeightWithSpacing()
Gets the frame height with spacing
Definition: ImGui.cs:9249
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetColumnIndex
static byte igTableSetColumnIndex(int columnN)
Igs the table set column index using the specified column n
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyDown_Nil
static byte igIsKeyDown_Nil(ImGuiKey key)
Igs the is key down nil using the specified key
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0)
Images the user texture id
Definition: ImGui.cs:9752
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopupOnItemClick
static void igOpenPopupOnItemClick(byte *strId, ImGuiPopups popups)
Igs the open popup on item click using the specified str id
Alis.Core.Graphic.ImGui.ImGui.GetFrameHeight
static float GetFrameHeight()
Gets the frame height
Definition: ImGui.cs:9239
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetForegroundDrawList_Nil
static ImDrawList * igGetForegroundDrawList_Nil()
Igs the get foreground draw list nil
Alis.Core.Graphic.ImGui.ImGui.VSliderFloat
static bool VSliderFloat(string label, Vector2F size, ref float v, float vMin, float vMax)
Describes whether v slider float
Definition: ImGui.cs:21043
Alis.Core.Graphic.ImGui.ImGui.PushStyleVar
static void PushStyleVar(ImGuiStyleVar idx, float val)
Pushes the style var using the specified idx
Definition: ImGui.cs:15322
Alis.Core.Graphic.ImGui.ImGui.AlignTextToFramePadding
static void AlignTextToFramePadding()
Aligns the text to frame padding
Definition: ImGui.cs:130
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetClipboardText
static byte * igGetClipboardText()
Igs the get clipboard text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollHereY
static void igSetScrollHereY(float centerYRatio)
Igs the set scroll here y using the specified center y ratio
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemHovered
static byte igIsItemHovered(ImGuiHovereds flag)
Igs the is item hovered using the specified flags
Alis.Core.Graphic.ImGui.ImGui.IsWindowAppearing
static bool IsWindowAppearing()
Describes whether is window appearing
Definition: ImGui.cs:12944
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt4
static byte igDragInt4(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the drag int 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.ColorConvertHsVtoRgb
static void ColorConvertHsVtoRgb(float h, float s, float v, out float outR, out float outG, out float outB)
Colors the convert hs vto rgb using the specified h
Definition: ImGui.cs:2398
Alis.Core.Graphic.ImGui.Delegates.ImGuiSizeCallback
unsafe delegate void ImGuiSizeCallback(ImGuiSizeCallbackData *data)
The im gui size callback
Alis.Core.Graphic.ImGui.ImGui.GetFrameCount
static int GetFrameCount()
Gets the frame count
Definition: ImGui.cs:9229
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col, ImGuiColorEdits flag)
Describes whether color button
Definition: ImGui.cs:2302
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginDragDropSource
static byte igBeginDragDropSource(ImGuiDragDrops flag)
Igs the begin drag drop source using the specified flags
Alis
Definition: IConfiguration.cs:31
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string strId, ImGuiTreeNodes flag, string fmt)
Describes whether tree node ex
Definition: ImGui.cs:20634
Alis.Core.Graphic.ImGui.ImGui.OpenPopupOnItemClick
static void OpenPopupOnItemClick(string strId, ImGuiPopups popups)
Opens the popup on item click using the specified str id
Definition: ImGui.cs:14079
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name)
Describes whether begin popup modal
Definition: ImGui.cs:1297
Alis.Core.Graphic.ImGui.ImGui.GetBackgroundDrawList
static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
Gets the background draw list using the specified viewport
Definition: ImGui.cs:8930
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowFontSelector
static void igShowFontSelector(byte *label)
Igs the show font selector using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorEdit3
static byte igColorEdit3(byte *label, Vector3F *col, ImGuiColorEdits flag)
Igs the color edit 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetWindowContentRegionMin
static Vector2F GetWindowContentRegionMin()
Gets the window content region min
Definition: ImGui.cs:9643
Alis.Core.Graphic.ImGui.ImGui.SetNextFrameWantCaptureKeyboard
static void SetNextFrameWantCaptureKeyboard(bool wantCaptureKeyboard)
Sets the next frame want capture keyboard using the specified want capture keyboard
Definition: ImGui.cs:16216
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextFrameWantCaptureKeyboard
static void igSetNextFrameWantCaptureKeyboard(byte wantCaptureKeyboard)
Igs the set next frame want capture keyboard using the specified want capture keyboard
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 2
Definition: ImGui.cs:4119
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igArrowButton
static byte igArrowButton(byte *strId, ImGuiDir dir)
Igs the arrow button using the specified str id
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label)
Tables the setup column using the specified label
Definition: ImGui.cs:20055
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSelectable_BoolPtr
static byte igSelectable_BoolPtr(byte *label, byte *pSelected, ImGuiSelectables flag, Vector2F size)
Igs the selectable bool ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount)
Plots the lines using the specified label
Definition: ImGui.cs:14586
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether slider float 3
Definition: ImGui.cs:18107
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
Describes whether slider scalar n
Definition: ImGui.cs:19590
Alis.Core.Graphic.ImGui.ImGui.GetFontSize
static float GetFontSize()
Gets the font size
Definition: ImGui.cs:9186
Alis.Core.Graphic.ImGui.ImGui.EndDragDropSource
static void EndDragDropSource()
Ends the drag drop source
Definition: ImGui.cs:8771
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id, Vector2F size)
Describes whether begin child
Definition: ImGui.cs:494
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether drag float
Definition: ImGui.cs:3844
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol)
Describes whether image button
Definition: ImGui.cs:9947
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(Vector2F size, ImGuiCond cond)
Sets the window size using the specified size
Definition: ImGui.cs:16889
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSize
static void SetNextWindowSize(Vector2F size, ImGuiCond cond)
Sets the next window size using the specified size
Definition: ImGui.cs:16398
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igFindViewportByPlatformHandle
static ImGuiViewport * igFindViewportByPlatformHandle(void *platformHandle)
Igs the find viewport by platform handle using the specified platform handle
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v)
Describes whether drag int 2
Definition: ImGui.cs:6182
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowCollapsed_Bool
static void igSetWindowCollapsed_Bool(byte collapsed, ImGuiCond cond)
Igs the set window collapsed bool using the specified collapsed
Alis.Core.Graphic.ImGui.ImGui.GetStyleColorName
static string GetStyleColorName(ImGuiCol idx)
Gets the style color name using the specified idx
Definition: ImGui.cs:9561
Alis.Core.Graphic.ImGui.ImGui.StyleColorsLight
static void StyleColorsLight(ImGuiStylePtr dst)
Styles the colors light using the specified dst
Definition: ImGui.cs:19753
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(IntPtr ptrId, ImGuiTreeNodes flag, string fmt)
Describes whether tree node ex
Definition: ImGui.cs:20703
Alis.Core.Graphic.ImGui.ImGui.ShowDebugLogWindow
static void ShowDebugLogWindow(ref bool pOpen)
Shows the debug log window using the specified p open
Definition: ImGui.cs:17004
Alis.Core.Graphic.ImGui.ImGui.PopButtonRepeat
static void PopButtonRepeat()
Pops the button repeat
Definition: ImGui.cs:15052
Alis.Core.Graphic.ImGui.ImGui.BeginGroup
static void BeginGroup()
Begins the group
Definition: ImGui.cs:750
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax)
Describes whether drag float range 2
Definition: ImGui.cs:5550
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format, string formatMax, ImGuiSliders flag)
Describes whether drag float range 2
Definition: ImGui.cs:5660
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMainViewport
static ImGuiViewport * igGetMainViewport()
Igs the get main viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igImageButton
static byte igImageButton(byte *strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
Igs the image button using the specified str id
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 4
Definition: ImGui.cs:4959
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushFont
static void igPushFont(ImFont *font)
Igs the push font using the specified font
Alis.Core.Graphic.ImGui.ImGui.SetWindowSize
static void SetWindowSize(string name, Vector2F size, ImGuiCond cond)
Sets the window size using the specified name
Definition: ImGui.cs:16938
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep)
Describes whether input scalar
Definition: ImGui.cs:11873
Alis.Core.Graphic.ImGui.Enums.ImGuiMouseCursor
ImGuiMouseCursor
The im gui mouse cursor enum
Definition: ImGuiMouseCursor.cs:36
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(string name, bool collapsed)
Sets the window collapsed using the specified name
Definition: ImGui.cs:16652
Alis.Core.Graphic.ImGui.ImGui.IsAnyItemHovered
static bool IsAnyItemHovered()
Describes whether is any item hovered
Definition: ImGui.cs:12516
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosY
static void SetScrollFromPosY(float localY)
Sets the scroll from pos y using the specified local y
Definition: ImGui.cs:16473
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Bool
static void igValue_Bool(byte *prefix, byte b)
Igs the value bool using the specified prefix
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDebugCheckVersionAndDataLayout
static byte igDebugCheckVersionAndDataLayout(byte *versionStr, uint szIo, uint szStyle, uint szVec2, uint szVec4, uint szDrawvert, uint szDrawidx)
Igs the debug check version and data layout using the specified version str
Alis.Core.Aspect.Math.Vector
Definition: Vector2B.cs:33
Alis.Core.Graphic.ImGui.Structs.ImDrawDataPtr
The im draw data ptr
Definition: ImDrawDataPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(string name, Vector2F pos)
Sets the window pos using the specified name
Definition: ImGui.cs:16803
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax, string format)
Describes whether slider float 3
Definition: ImGui.cs:18031
Alis.Core.Graphic.ImGui.ImGui.EndGroup
static void EndGroup()
Ends the group
Definition: ImGui.cs:8795
Alis.Core.Graphic.ImGui.Structs.ImGuiIoPtr
The im gui io ptr
Definition: ImGuiIOPtr.cs:42
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableHeadersRow
static void igTableHeadersRow()
Igs the table headers row
Alis.Core.Graphic.ImGui.ImGui.EndMenuBar
static void EndMenuBar()
Ends the menu bar
Definition: ImGui.cs:8827
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetRowIndex
static int igTableGetRowIndex()
Igs the table get row index
Alis.Core.Graphic.ImGui.ImGui.StyleColorsClassic
static void StyleColorsClassic(ImGuiStylePtr dst)
Styles the colors classic using the specified dst
Definition: ImGui.cs:19715
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(int intId)
Pushes the id using the specified int id
Definition: ImGui.cs:15283
Alis.Core.Graphic.ImGui.ImGui.SliderInt4
static bool SliderInt4(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 4
Definition: ImGui.cs:19111
Alis.Core.Graphic.ImGui.Enums.ImGuiFocus
ImGuiFocus
The im gui focused flags enum
Definition: ImGuiFocus.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextVoid
static byte igBeginPopupContextVoid(byte *strId, ImGuiPopups popups)
Igs the begin popup context void using the specified str id
Alis.Core.Graphic.ImGui.ImGui.Separator
static void Separator()
Separators
Definition: ImGui.cs:15909
Alis.Core.Graphic.ImGui.ImGui.LogToClipboard
static void LogToClipboard()
Logs the to clipboard
Definition: ImGui.cs:13396
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBullet
static void igBullet()
Igs the bullet
Alis.Core.Graphic.ImGui.ImGui.AcceptDragDropPayload
static ImGuiPayloadPtr AcceptDragDropPayload(string type)
Accepts the drag drop payload using the specified type
Definition: ImGui.cs:52
Alis.Core.Graphic.ImGui.ImGui.CreateContext
static IntPtr CreateContext()
Creates the context
Definition: ImGui.cs:3250
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16408
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetColumnEnabled
static void igTableSetColumnEnabled(int columnN, byte v)
Igs the table set column enabled using the specified column n
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether slider float 4
Definition: ImGui.cs:18323
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, bool selected)
Describes whether menu item
Definition: ImGui.cs:13626
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.Enums.ImGuiDragDrops
ImGuiDragDrops
The im gui drag drop flags enum
Definition: ImGuiDragDrops.cs:39
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
Describes whether drag scalar n
Definition: ImGui.cs:8575
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTexts flag)
Describes whether input scalar n
Definition: ImGui.cs:12345
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColumnOffset
static void igSetColumnOffset(int columnIndex, float offsetX)
Igs the set column offset using the specified column index
Alis.Core.Graphic.ImGui.Enums.ImGuiCombos
ImGuiCombos
The im gui combo flags enum
Definition: ImGuiCombos.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBegin
static byte igBegin(byte *name, byte *pOpen, ImGuiWindows flag)
Igs the begin using the specified name
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether drag int 2
Definition: ImGui.cs:6531
Alis.Core.Graphic.ImGui.Utils
Definition: Unsafe.cs:36
Alis.Core.Graphic.ImGui.Structs.ImFontPtr.NativePtr
ImFont * NativePtr
Gets the value of the native ptr
Definition: ImFontPtr.cs:44
Alis.Core.Graphic.ImGui.Utils.Util.Allocate
static byte * Allocate(int byteCount)
Allocates the byte count
Alis.Core.Graphic.ImGui.ImGui.StyleColorsClassic
static void StyleColorsClassic()
Styles the colors classic
Definition: ImGui.cs:19705
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetBackgroundDrawList_ViewportPtr
static ImDrawList * igGetBackgroundDrawList_ViewportPtr(ImGuiViewport *viewport)
Igs the get background draw list viewport ptr using the specified viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndGroup
static void igEndGroup()
Igs the end group
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFontSize
static float igGetFontSize()
Igs the get font size
Alis.Core.Graphic.ImGui.ImGui.End
static void End()
Ends
Definition: ImGui.cs:8731
Alis.Core.Graphic.ImGui.ImGui.IsWindowCollapsed
static bool IsWindowCollapsed()
Describes whether is window collapsed
Definition: ImGui.cs:12954
Alis.Core.Graphic.ImGui.ImGui.DestroyContext
static void DestroyContext()
Destroys the context
Definition: ImGui.cs:3353
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label, ref bool pOpen, ImGuiTabItems flag)
Describes whether begin tab item
Definition: ImGui.cs:1593
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat
static byte igDragFloat(byte *label, float *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the drag float using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginListBox
static bool BeginListBox(string label)
Describes whether begin list box
Definition: ImGui.cs:760
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyName
static byte * igGetKeyName(ImGuiKey key)
Igs the get key name using the specified key
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v, string format)
Describes whether input float 3
Definition: ImGui.cs:11022
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetAllocatorFunctions
static void igGetAllocatorFunctions(IntPtr *pAllocFunc, IntPtr *pFreeFunc, void **pUserData)
Igs the get allocator functions using the specified p alloc func
Alis.Core.Graphic.ImGui.Enums.ImGuiTableRows
ImGuiTableRows
The im gui table row flags enum
Definition: ImGuiTableRows.cs:39
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label, ref bool pOpen)
Describes whether begin tab item
Definition: ImGui.cs:1548
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCurrentContext
static IntPtr igGetCurrentContext()
Igs the get current context
Alis.Core.Graphic.ImGui.Enums.ImGuiPopups
ImGuiPopups
The im gui popup flags enum
Definition: ImGuiPopups.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(Vector4F col)
Gets the color u 32 using the specified col
Definition: ImGui.cs:8976
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderAngle
static byte igSliderAngle(byte *label, float *vRad, float vDegreesMin, float vDegreesMax, byte *format, ImGuiSliders flag)
Igs the slider angle using the specified label
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, ref bool pSelected, bool enabled)
Describes whether menu item
Definition: ImGui.cs:13843
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemEdited
static byte igIsItemEdited()
Igs the is item edited
Alis.Core.Graphic.ImGui.ImGui.GetColumnOffset
static float GetColumnOffset()
Gets the column offset
Definition: ImGui.cs:9007
Alis.Core.Graphic.ImGui.ImGui.SetMouseCursor
static void SetMouseCursor(ImGuiMouseCursor cursorType)
Sets the mouse cursor using the specified cursor type
Definition: ImGui.cs:16207
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDockSpaceOverViewport
static uint igDockSpaceOverViewport(ImGuiViewport *viewport, ImGuiDockNodes flag, ImGuiWindowClass *windowClass)
Igs the dock space over viewport using the specified viewport
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStateStorage
static ImGuiStorage * igGetStateStorage()
Igs the get state storage
Alis.Core.Graphic.ImGui
Definition: NonVersionableAttribute.cs:33
Alis.Core.Graphic.ImGui.ImGui.IsItemToggledOpen
static bool IsItemToggledOpen()
Describes whether is item toggled open
Definition: ImGui.cs:12640
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax, string format)
Describes whether slider scalar n
Definition: ImGui.cs:19512
Alis.Core.Graphic.ImGui.Structs.ImGuiNative
The im gui native class
Definition: ImGuiNative.cs:42
Alis.Core.Graphic.ImGui.Utils.Util
The util class
Definition: Util.cs:40
Alis.Core.Graphic.ImGui.ImGui.TableSetBgColor
static void TableSetBgColor(ImGuiTableBgTarget target, uint color)
Tables the set bg color using the specified target
Definition: ImGui.cs:20012
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFontScale
static void igSetWindowFontScale(float scale)
Igs the set window font scale using the specified scale
Alis.Core.Graphic.ImGui.ImGui.PushFont
static void PushFont(ImFontPtr font)
Pushes the font using the specified font
Definition: ImGui.cs:15227
Alis.Core.Graphic.ImGui.ImGui.SetNextItemOpen
static void SetNextItemOpen(bool isOpen, ImGuiCond cond)
Sets the next item open using the specified is open
Definition: ImGui.cs:16248
Alis.Core.Graphic.ImGui.Enums.ImGuiColorEdits
ImGuiColorEdits
The im gui color edit flags enum
Definition: ImGuiColorEdits.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRenderPlatformWindowsDefault
static void igRenderPlatformWindowsDefault(void *platformRenderArg, void *rendererRenderArg)
Igs the render platform windows default using the specified platform render arg
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Int
static void igPushID_Int(int intId)
Igs the push id int using the specified int id
Alis.Core.Graphic.ImGui.ImGui.IsRectVisible
static bool IsRectVisible(Vector2F rectMin, Vector2F rectMax)
Describes whether is rect visible
Definition: ImGui.cs:12934
Alis.Core.Graphic.ImGui.ImGui.GetWindowDockId
static uint GetWindowDockId()
Gets the window dock id
Definition: ImGui.cs:9654
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnIndex
static int igTableGetColumnIndex()
Igs the table get column index
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v)
Describes whether input int
Definition: ImGui.cs:11377
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollY
static float igGetScrollY()
Igs the get scroll y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTextLineHeightWithSpacing
static float igGetTextLineHeightWithSpacing()
Igs the get text line height with spacing
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed)
Describes whether drag int 4
Definition: ImGui.cs:7090
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed)
Describes whether drag int 3
Definition: ImGui.cs:6670
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax)
Describes whether v slider int
Definition: ImGui.cs:21262
Alis.Core.Graphic.ImGui.ImGui.SliderInt2
static bool SliderInt2(string label, ref int v, int vMin, int vMax)
Describes whether slider int 2
Definition: ImGui.cs:18612
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, bool selected, bool enabled)
Describes whether menu item
Definition: ImGui.cs:13698
Alis.Core.Graphic.ImGui.ImGui.Text
static void Text(string fmt)
Texts the fmt
Definition: ImGui.cs:20221
Alis.Core.Graphic.ImGui.ImGui.SetTooltip
static void SetTooltip(string fmt)
Sets the tooltip using the specified fmt
Definition: ImGui.cs:16593
Alis.Core.Graphic.ImGui.ImGui.TabItemButton
static bool TabItemButton(string label)
Describes whether tab item button
Definition: ImGui.cs:19764
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetBackgroundDrawList_Nil
static ImDrawList * igGetBackgroundDrawList_Nil()
Igs the get background draw list nil
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Ptr
static void igPushID_Ptr(void *ptrId)
Igs the push id ptr using the specified ptr id
Alis.Core.Graphic.ImGui.ImGui.SetCursorPos
static void SetCursorPos(Vector2F localPos)
Sets the cursor pos using the specified local pos
Definition: ImGui.cs:16051
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosX
static void SetScrollFromPosX(float localX)
Sets the scroll from pos x using the specified local x
Definition: ImGui.cs:16453
Alis.Core.Graphic.ImGui.ImGui.SetNextItemWidth
static void SetNextItemWidth(float itemWidth)
Sets the next item width using the specified item width
Definition: ImGui.cs:16258
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowViewport
static void SetNextWindowViewport(uint viewportId)
Sets the next window viewport using the specified viewport id
Definition: ImGui.cs:16444
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igAlignTextToFramePadding
static void igAlignTextToFramePadding()
Igs the align text to frame padding
Alis.Core.Graphic.ImGui.Structs.ImGuiViewportPtr
The im gui viewport ptr
Definition: ImGuiViewportPtr.cs:41
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopFont
static void igPopFont()
Igs the pop font
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTooltip
static void igEndTooltip()
Igs the end tooltip
Alis.Core.Graphic.ImGui.ImGui.IsItemActivated
static bool IsItemActivated()
Describes whether is item activated
Definition: ImGui.cs:12536
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin)
Describes whether drag float range 2
Definition: ImGui.cs:5322
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowDpiScale
static float igGetWindowDpiScale()
Igs the get window dpi scale
Alis.Core.Graphic.ImGui.ImGui.GetContentRegionAvail
static Vector2F GetContentRegionAvail()
Gets the content region avail
Definition: ImGui.cs:9061
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetStyleColorVec4
static Vector4F * igGetStyleColorVec4(ImGuiCol idx)
Igs the get style color vec 4 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.DestroyContext
static void DestroyContext(IntPtr ctx)
Destroys the context using the specified ctx
Definition: ImGui.cs:3363
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderScalar
static byte igVSliderScalar(byte *label, Vector2F size, ImGuiDataType dataType, void *pData, void *pMin, void *pMax, byte *format, ImGuiSliders flag)
Igs the v slider scalar using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLoadIniSettingsFromMemory
static void igLoadIniSettingsFromMemory(byte *iniData, uint iniSize)
Igs the load ini settings from memory using the specified ini data
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pStep)
Describes whether input scalar n
Definition: ImGui.cs:12168
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowSize_Str
static void igSetWindowSize_Str(byte *name, Vector2F size, ImGuiCond cond)
Igs the set window size str using the specified name
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogText
static void igLogText(byte *fmt)
Igs the log text using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.ShowDemoWindow
static void ShowDemoWindow(ref bool pOpen)
Shows the demo window using the specified p open
Definition: ImGui.cs:17025
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction, Vector2F sizeArg, string overlay)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15169
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsDark
static void igStyleColorsDark(ImGuiStyle *dst)
Igs the style colors dark using the specified dst
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDummy
static void igDummy(Vector2F size)
Igs the dummy using the specified size
Alis.Core.Graphic.ImGui.ImGui.TableGetRowIndex
static int TableGetRowIndex()
Tables the get row index
Definition: ImGui.cs:19907
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChildFrame
static byte igBeginChildFrame(uint id, Vector2F size, ImGuiWindows flag)
Igs the begin child frame using the specified id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemHovered
static byte igIsAnyItemHovered()
Igs the is any item hovered
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsLight
static void igStyleColorsLight(ImGuiStyle *dst)
Igs the style colors light using the specified dst
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.SetCursorPosX
static void SetCursorPosX(float localX)
Sets the cursor pos x using the specified local x
Definition: ImGui.cs:16060
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.PushTextWrapPos
static void PushTextWrapPos(float wrapLocalPosX)
Pushes the text wrap pos using the specified wrap local pos x
Definition: ImGui.cs:15360
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax)
Describes whether drag float 3
Definition: ImGui.cs:4539
Alis.Core.Graphic.ImGui.ImGui.ColorConvertU32ToFloat4
static Vector4F ColorConvertU32ToFloat4(uint @in)
/
Definition: ImGui.cs:2440
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTabItem
static byte igBeginTabItem(byte *label, byte *pOpen, ImGuiTabItems flag)
Igs the begin tab item using the specified label
Alis.Core.Graphic.ImGui.ImGui.PopStyleVar
static void PopStyleVar()
Pops the style var
Definition: ImGui.cs:15110
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol)
Images the user texture id
Definition: ImGui.cs:9782
Alis.Core.Graphic.ImGui.ImGui.GetScrollX
static float GetScrollX()
Gets the scroll x
Definition: ImGui.cs:9520
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetMouseCursor
static void igSetMouseCursor(ImGuiMouseCursor cursorType)
Igs the set mouse cursor using the specified cursor type
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast)
Describes whether input double
Definition: ImGui.cs:10185
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 4
Definition: ImGui.cs:7226
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNewFrame
static void igNewFrame()
Igs the new frame
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igVSliderFloat
static byte igVSliderFloat(byte *label, Vector2F size, float *v, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the v slider float using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetCurrentContext
static IntPtr GetCurrentContext()
Gets the current context
Definition: ImGui.cs:9083
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText)
Plots the lines using the specified label
Definition: ImGui.cs:14682
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDrawListSharedData
static IntPtr igGetDrawListSharedData()
Igs the get draw list shared data
Alis.Core.Graphic.ImGui.ImGui.GetMainViewport
static ImGuiViewportPtr GetMainViewport()
Gets the main viewport
Definition: ImGui.cs:9398
Alis.Core.Graphic.ImGui.ImGui.NewLine
static void NewLine()
News the line
Definition: ImGui.cs:13920
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMenuBar
static void igEndMenuBar()
Igs the end menu bar
Alis.Core.Graphic.ImGui.ImGui.SetScrollY
static void SetScrollY(float scrollY)
Sets the scroll y using the specified scroll y
Definition: ImGui.cs:16538
Alis.Core.Graphic.ImGui.ImGui.SetWindowFocus
static void SetWindowFocus()
Sets the window focus
Definition: ImGui.cs:16728
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
Sets the window collapsed using the specified name
Definition: ImGui.cs:16692
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckboxFlags_IntPtr
static byte igCheckboxFlags_IntPtr(byte *label, int *flags, int flagsValue)
Igs the checkbox flags int ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetClipboardText
static void igSetClipboardText(byte *text)
Igs the set clipboard text using the specified text
Alis.Core.Graphic.ImGui.ImGui.BeginPopup
static bool BeginPopup(string strId, ImGuiWindows flag)
Describes whether begin popup
Definition: ImGui.cs:982
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopTextWrapPos
static void igPopTextWrapPos()
Igs the pop text wrap pos
Alis.Core.Graphic.ImGui.ImGui.CalcItemWidth
static float CalcItemWidth()
Calcs the item width
Definition: ImGui.cs:1940
Alis.Core.Graphic.ImGui.ImGui.InputInt4
static bool InputInt4(string label, ref int v)
Describes whether input int 4
Definition: ImGui.cs:11737
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyPressed_Bool
static byte igIsKeyPressed_Bool(ImGuiKey key, byte repeat)
Igs the is key pressed bool using the specified key
Alis.Core.Graphic.ImGui.ImGui.GetForegroundDrawList
static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
Gets the foreground draw list using the specified viewport
Definition: ImGui.cs:9218
Alis.Core.Graphic.ImGui.ImGui.GetDragDropPayload
static ImGuiPayloadPtr GetDragDropPayload()
Gets the drag drop payload
Definition: ImGui.cs:9146
Alis.Core.Graphic.ImGui.ImGui.GetItemRectMax
static Vector2F GetItemRectMax()
Gets the item rect max
Definition: ImGui.cs:9330
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDragDropSource
static void igEndDragDropSource()
Igs the end drag drop source
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax)
Describes whether drag int range 2
Definition: ImGui.cs:7662
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.AcceptDragDropPayload
static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDrops flag)
Accepts the drag drop payload using the specified type
Definition: ImGui.cs:93
Alis.Core.Graphic.ImGui.Structs.ImGuiTableSortSpecsPtr
The im gui table sort specs ptr
Definition: ImGuiTableSortSpecsPtr.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetAllocatorFunctions
static void GetAllocatorFunctions(ref IntPtr pAllocFunc, ref IntPtr pFreeFunc, ref void *pUserData)
Gets the allocator functions using the specified p alloc func
Definition: ImGui.cs:8901
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(bool collapsed)
Sets the window collapsed using the specified collapsed
Definition: ImGui.cs:16629
Alis.Core.Graphic.ImGui.ImGui.GetMousePosOnOpeningCurrentPopup
static Vector2F GetMousePosOnOpeningCurrentPopup()
Gets the mouse pos on opening current popup
Definition: ImGui.cs:9479
Alis.Core.Graphic.ImGui.ImGui.GetCursorStartPos
static Vector2F GetCursorStartPos()
Gets the cursor start pos
Definition: ImGui.cs:9135
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextItemWidth
static void igSetNextItemWidth(float itemWidth)
Igs the set next item width using the specified item width
Alis.Core.Graphic.ImGui.ImGui.GetColorU32
static uint GetColorU32(ImGuiCol idx, float alphaMul)
Gets the color u 32 using the specified idx
Definition: ImGui.cs:8965
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTexts flag)
Describes whether input text multiline
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMemAlloc
static void * igMemAlloc(uint size)
Igs the mem alloc using the specified size
Alis.Core.Graphic.ImGui.Utils.Util.StringFromPtr
static string StringFromPtr(byte *ptr)
Strings the from ptr using the specified ptr
Definition: Util.cs:51
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTreeNodeToLabelSpacing
static float igGetTreeNodeToLabelSpacing()
Igs the get tree node to label spacing
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDrawData
static ImDrawData * igGetDrawData()
Igs the get draw data
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertFloat4ToU32
static uint igColorConvertFloat4ToU32(Vector4F @in)
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInvisibleButton
static byte igInvisibleButton(byte *strId, Vector2F size, ImGuiButtons flag)
Igs the invisible button using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetItemAllowOverlap
static void igSetItemAllowOverlap()
Igs the set item allow overlap
Alis.Core.Graphic.ImGui.ImGui.ShowAboutWindow
static void ShowAboutWindow(ref bool pOpen)
Shows the about window using the specified p open
Definition: ImGui.cs:16983
Alis.Core.Graphic.ImGui.Enums
Definition: ImDrawLists.cs:33
Alis.Core.Graphic.ImGui.ImGui.ColorConvertFloat4ToU32
static uint ColorConvertFloat4ToU32(Vector4F @in)
Definition: ImGui.cs:2383
Alis.Core.Graphic.ImGui.ImGui.BeginTooltip
static bool BeginTooltip()
Describes whether begin tooltip
Definition: ImGui.cs:1806
Alis.Core.Graphic.ImGui.ImGui.IsMouseHoveringRect
static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax, bool clip)
Describes whether is mouse hovering rect
Definition: ImGui.cs:12794
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(uint id)
Describes whether begin child
Definition: ImGui.cs:479
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereY
static void SetScrollHereY()
Sets the scroll here y
Definition: ImGui.cs:16510
Alis.Core.Graphic.ImGui.ImGui.GetFont
static ImFontPtr GetFont()
Gets the font
Definition: ImGui.cs:9176
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem(string strId, ImGuiPopups popups)
Describes whether begin popup context item
Definition: ImGui.cs:1074
Alis.Core.Graphic.ImGui.ImGui.SetCursorScreenPos
static void SetCursorScreenPos(Vector2F pos)
Sets the cursor screen pos using the specified pos
Definition: ImGui.cs:16078
Alis.Core.Graphic.ImGui.ImGui.SliderInt
static bool SliderInt(string label, ref int v, int vMin, int vMax)
Describes whether slider int
Definition: ImGui.cs:18396
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow(string strId)
Describes whether begin popup context window
Definition: ImGui.cs:1217
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format)
Describes whether slider angle
Definition: ImGui.cs:17383
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemDeactivatedAfterEdit
static byte igIsItemDeactivatedAfterEdit()
Igs the is item deactivated after edit
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderInt3
static byte igSliderInt3(byte *label, int *v, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the slider int 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndCombo
static void igEndCombo()
Igs the end combo
Alis.Core.Graphic.ImGui.ImGui.IsMouseDoubleClicked
static bool IsMouseDoubleClicked(ImGuiMouseButton button)
Describes whether is mouse double clicked
Definition: ImGui.cs:12733
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnFlags
static ImGuiTableColumns TableGetColumnFlags(int columnN)
Tables the get column flags using the specified column n
Definition: ImGui.cs:19865
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseHoveringRect
static byte igIsMouseHoveringRect(Vector2F rMin, Vector2F rMax, byte clip)
Igs the is mouse hovering rect using the specified r min
Alis.Core.Graphic.ImGui.ImGui.GetItemId
static uint GetItemId()
Gets the item id
Definition: ImGui.cs:9320
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTexts flag)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(string strId, ImGuiPopups popups)
Opens the popup using the specified str id
Definition: ImGui.cs:13975
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igListBox_Str_arr
static byte igListBox_Str_arr(byte *label, int *currentItem, byte **items, int itemsCount, int heightInItems)
Igs the list box str arr using the specified label
Alis.Core.Graphic.ImGui.ImGui.BulletText
static void BulletText(string fmt)
Bullets the text using the specified fmt
Definition: ImGui.cs:1824
Alis.Core.Graphic.ImGui.ImGui.ShowStackToolWindow
static void ShowStackToolWindow(ref bool pOpen)
Shows the stack tool window using the specified p open
Definition: ImGui.cs:17103
Alis.Core.Graphic.ImGui.ImGui.Combo
static bool Combo(string label, ref int currentItem, string[] items, int itemsCount)
Describes whether combo
Definition: ImGui.cs:2956
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextDisabled
static void igTextDisabled(byte *fmt)
Igs the text disabled using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax, string format, ImGuiSliders flag)
Describes whether slider angle
Definition: ImGui.cs:17459
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile(int autoOpenDepth, string filename)
Logs the to file using the specified auto open depth
Definition: ImGui.cs:13436
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt3
static byte igInputInt3(byte *label, int *v, ImGuiInputTexts flag)
Igs the input int 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderInt3
static bool SliderInt3(string label, ref int v, int vMin, int vMax, string format)
Describes whether slider int 3
Definition: ImGui.cs:18895
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize, ImGuiInputTexts flag, ImGuiInputTextCallback callback, IntPtr userData)
Describes whether input text
Definition: ImGui.cs:22403
Alis.Core.Graphic.ImGui.Structs.ImGuiStoragePtr
The im gui storage ptr
Definition: ImGuiStoragePtr.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDestroyContext
static void igDestroyContext(IntPtr ctx)
Igs the destroy context using the specified ctx
Alis.Core.Graphic.ImGui.ImGui.GetBackgroundDrawList
static ImDrawListPtr GetBackgroundDrawList()
Gets the background draw list
Definition: ImGui.cs:8919
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemActivated
static byte igIsItemActivated()
Igs the is item activated
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMousePosValid
static byte igIsMousePosValid(Vector2F *mousePos)
Igs the is mouse pos valid using the specified mouse pos
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableNextColumn
static byte igTableNextColumn()
Igs the table next column
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereX
static void SetScrollHereX(float centerXRatio)
Sets the scroll here x using the specified center x ratio
Definition: ImGui.cs:16502
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetupColumn
static void igTableSetupColumn(byte *label, ImGuiTableColumns flag, float initWidthOrWeight, uint userId)
Igs the table setup column using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem(string strId)
Describes whether begin popup context item
Definition: ImGui.cs:1033
Alis.Core.Graphic.ImGui.ImGui.IsItemHovered
static bool IsItemHovered()
Describes whether is item hovered
Definition: ImGui.cs:12618
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollHereX
static void igSetScrollHereX(float centerXRatio)
Igs the set scroll here x using the specified center x ratio
Alis.Core.Graphic.ImGui.ImGui.DragFloat2
static bool DragFloat2(string label, ref Vector2F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 2
Definition: ImGui.cs:4187
Alis.Core.Graphic.ImGui.ImGui.BeginDisabled
static void BeginDisabled(bool disabled)
Begins the disabled using the specified disabled
Definition: ImGui.cs:709
Alis.Core.Graphic.ImGui.ImGui.LabelText
static void LabelText(string label, string fmt)
Labels the text using the specified label
Definition: ImGui.cs:13019
Alis.Core.Graphic.ImGui.ImGui.IsWindowFocused
static bool IsWindowFocused(ImGuiFocus flag)
Describes whether is window focused
Definition: ImGui.cs:12986
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength)
Describes whether input text
Alis.Core.Graphic.ImGui.ImGui.ShowStackToolWindow
static void ShowStackToolWindow()
Shows the stack tool window
Definition: ImGui.cs:17093
Alis.Core.Graphic.ImGui.ImGui.ShowStyleEditor
static void ShowStyleEditor()
Shows the style editor
Definition: ImGui.cs:17114
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameHeight
static float igGetFrameHeight()
Igs the get frame height
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin)
Describes whether slider angle
Definition: ImGui.cs:17249
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid()
Describes whether begin popup context void
Definition: ImGui.cs:1112
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v)
Describes whether input float 4
Definition: ImGui.cs:11167
Alis.Core.Graphic.ImGui.ImGui.ShowAboutWindow
static void ShowAboutWindow()
Shows the about window
Definition: ImGui.cs:16973
Alis.Core.Graphic.ImGui.ImGui.InputScalarN
static bool InputScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
Describes whether input scalar n
Definition: ImGui.cs:12120
Alis.Core.Graphic.ImGui.Enums.ImGuiTabBars
ImGuiTabBars
The im gui tab bar flags enum
Definition: ImGuiTabBars.cs:39
Alis.Core.Graphic.ImGui.ImGui.Indent
static void Indent()
Indents
Definition: ImGui.cs:10030
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMenuBar
static byte igBeginMenuBar()
Igs the begin menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLabelText
static void igLabelText(byte *label, byte *fmt)
Igs the label text using the specified label
Alis.Core.Graphic.ImGui.ImGui.InvisibleButton
static bool InvisibleButton(string strId, Vector2F size)
Describes whether invisible button
Definition: ImGui.cs:12416
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLoadIniSettingsFromDisk
static void igLoadIniSettingsFromDisk(byte *iniFilename)
Igs the load ini settings from disk using the specified ini filename
Alis.Core.Graphic.ImGui.ImGui.GetTextLineHeightWithSpacing
static float GetTextLineHeightWithSpacing()
Gets the text line height with spacing
Definition: ImGui.cs:9592
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopItemWidth
static void igPopItemWidth()
Igs the pop item width
Alis.Core.Graphic.ImGui.ImGui.BeginTabItem
static bool BeginTabItem(string label)
Describes whether begin tab item
Definition: ImGui.cs:1506
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v)
Describes whether input double
Definition: ImGui.cs:10051
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowAppearing
static byte igIsWindowAppearing()
Igs the is window appearing
Alis.Core.Graphic.ImGui.Structs.ImFontPtr
The im font ptr
Definition: ImFontPtr.cs:40
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderScalar
static byte igSliderScalar(byte *label, ImGuiDataType dataType, void *pData, void *pMin, void *pMax, byte *format, ImGuiSliders flag)
Igs the slider scalar using the specified label
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowCollapsed
static void SetNextWindowCollapsed(bool collapsed)
Sets the next window collapsed using the specified collapsed
Definition: ImGui.cs:16286
Alis.Core.Graphic.ImGui.ImGui.GetTextLineHeight
static float GetTextLineHeight()
Gets the text line height
Definition: ImGui.cs:9582
Alis.Core.Graphic.ImGui.ImGui.ColorEdit4
static bool ColorEdit4(string label, ref Vector4F col, ImGuiColorEdits flag)
Describes whether color edit 4
Definition: ImGui.cs:2586
Alis.Core.Graphic.ImGui.ImGui.BeginTabBar
static bool BeginTabBar(string strId, ImGuiTabBars flag)
Describes whether begin tab bar
Definition: ImGui.cs:1467
Alis.Core.Graphic.ImGui.Structs.ImGuiTableSortSpecs
The im gui table sort specs
Definition: ImGuiTableSortSpecs.cs:36
Alis.Core.Graphic
Definition: Button.cs:31
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSameLine
static void igSameLine(float offsetFromStartX, float spacing)
Igs the same line using the specified offset from start x
Alis.Core.Graphic.ImGui.ImGui.TableHeadersRow
static void TableHeadersRow()
Tables the headers row
Definition: ImGui.cs:19962
Alis.Core.Graphic.ImGui.ImGui.ResetMouseDragDelta
static void ResetMouseDragDelta(ImGuiMouseButton button)
Resets the mouse drag delta using the specified button
Definition: ImGui.cs:15504
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size, bool border)
Describes whether begin child
Definition: ImGui.cs:395
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTables flag, Vector2F outerSize)
Describes whether begin table
Definition: ImGui.cs:1724
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopupContextItem
static byte igBeginPopupContextItem(byte *strId, ImGuiPopups popups)
Igs the begin popup context item using the specified str id
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, ref string input, uint maxLength, ImGuiInputTexts flag, ImGuiInputTextCallback callback)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDoubleClicked
static byte igIsMouseDoubleClicked(ImGuiMouseButton button)
Igs the is mouse double clicked using the specified button
Alis.Core.Graphic.ImGui.Utils.Util.AreStringsEqual
static bool AreStringsEqual(byte *a, int aLength, byte *b)
Describes whether are strings equal
Definition: Util.cs:69
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowCollapsed
static void igSetNextWindowCollapsed(byte collapsed, ImGuiCond cond)
Igs the set next window collapsed using the specified collapsed
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyItemFocused
static byte igIsAnyItemFocused()
Igs the is any item focused
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushID_Str
static void igPushID_Str(byte *strId)
Igs the push id str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad, float vDegreesMin, float vDegreesMax)
Describes whether slider angle
Definition: ImGui.cs:17316
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorButton
static byte igColorButton(byte *descId, Vector4F col, ImGuiColorEdits flag, Vector2F size)
Igs the color button using the specified desc id
Alis.Core.Graphic.ImGui.Enums.ImGuiInputTexts
ImGuiInputTexts
The im gui input text flags enum
Definition: ImGuiInputTexts.cs:39
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(string strId)
Pushes the id using the specified str id
Definition: ImGui.cs:15237
Alis.Core.Graphic.ImGui.ImGui.ShowMetricsWindow
static void ShowMetricsWindow()
Shows the metrics window
Definition: ImGui.cs:17072
Alis.Core.Graphic.ImGui.Enums.ImGuiTableColumns
ImGuiTableColumns
The im gui table column flags enum
Definition: ImGuiTableColumns.cs:39
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected)
Describes whether selectable
Definition: ImGui.cs:15777
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetTextLineHeight
static float igGetTextLineHeight()
Igs the get text line height
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether drag float 3
Definition: ImGui.cs:4684
Alis.Core.Graphic.ImGui.ImGui.IsItemHovered
static bool IsItemHovered(ImGuiHovereds flag)
Describes whether is item hovered
Definition: ImGui.cs:12630
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollX
static float igGetScrollX()
Igs the get scroll x
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed)
Describes whether drag scalar
Definition: ImGui.cs:8078
Alis.Core.Graphic.ImGui.ImGui.PopStyleVar
static void PopStyleVar(int count)
Pops the style var using the specified count
Definition: ImGui.cs:15120
Alis.Core.Graphic.ImGui.Structs.ImDrawData
The im draw data
Definition: ImDrawData.cs:38
Alis.Core.Graphic.ImGui.ImGui.EndDragDropTarget
static void EndDragDropTarget()
Ends the drag drop target
Definition: ImGui.cs:8779
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igValue_Uint
static void igValue_Uint(byte *prefix, uint v)
Igs the value uint using the specified prefix
Alis.Core.Graphic.ImGui.Structs
Definition: ImColor.cs:33
Alis.Core.Graphic.ImGui.ImGui.Checkbox
static bool Checkbox(string label, ref bool v)
Describes whether checkbox
Definition: ImGui.cs:1952
Alis.Core.Graphic.ImGui.ImGui.SetWindowPos
static void SetWindowPos(Vector2F pos, ImGuiCond cond)
Sets the window pos using the specified pos
Definition: ImGui.cs:16793
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igLogToFile
static void igLogToFile(int autoOpenDepth, byte *filename)
Igs the log to file using the specified auto open depth
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow()
Tables the next row
Definition: ImGui.cs:19980
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine(float offsetFromStartX, float spacing)
Sames the line using the specified offset from start x
Definition: ImGui.cs:15534
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDestroyPlatformWindows
static void igDestroyPlatformWindows()
Igs the destroy platform windows
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTabBar
static byte igBeginTabBar(byte *strId, ImGuiTabBars flag)
Igs the begin tab bar using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowCollapsed_Str
static void igSetWindowCollapsed_Str(byte *name, byte collapsed, ImGuiCond cond)
Igs the set window collapsed str using the specified name
Alis.Core.Graphic.ImGui.ImGui.SetAllocatorFunctions
static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc)
Sets the allocator functions using the specified alloc func
Definition: ImGui.cs:15955
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed)
Describes whether drag int 2
Definition: ImGui.cs:6250
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorConvertRGBtoHSV
static void igColorConvertRGBtoHSV(float r, float g, float b, float *outH, float *outS, float *outV)
Igs the color convert rg bto hsv using the specified r
Alis.Core.Graphic.ImGui.ImGui.ShowDemoWindow
static void ShowDemoWindow()
Shows the demo window
Definition: ImGui.cs:17015
Alis.Core.Graphic.ImGui.ImGui.IsWindowDocked
static bool IsWindowDocked()
Describes whether is window docked
Definition: ImGui.cs:12964
Alis.Core.Graphic.ImGui.ImGui.PushId
static void PushId(IntPtr ptrId)
Pushes the id using the specified ptr id
Definition: ImGui.cs:15273
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed)
Describes whether drag float range 2
Definition: ImGui.cs:5249
Alis.Core.Graphic.ImGui.ImGui.IsItemEdited
static bool IsItemEdited()
Describes whether is item edited
Definition: ImGui.cs:12598
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label)
Describes whether collapsing header
Definition: ImGui.cs:2090
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed)
Describes whether drag float 4
Definition: ImGui.cs:4823
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format, ImGuiSliders flag)
Describes whether drag float 4
Definition: ImGui.cs:5104
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_Col
static uint igGetColorU32_Col(ImGuiCol idx, float alphaMul)
Igs the get color u 32 col using the specified idx
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax, string format)
Describes whether slider float 4
Definition: ImGui.cs:18247
Alis.Core.Graphic.ImGui.ImGui.PopItemWidth
static void PopItemWidth()
Pops the item width
Definition: ImGui.cs:15084
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMainMenuBar
static byte igBeginMainMenuBar()
Igs the begin main menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCursorScreenPos
static void igSetCursorScreenPos(Vector2F pos)
Igs the set cursor screen pos using the specified pos
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin)
Describes whether drag scalar n
Definition: ImGui.cs:8474
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow(ImGuiTableRows rows)
Tables the next row using the specified row flags
Definition: ImGui.cs:19991
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemDeactivated
static byte igIsItemDeactivated()
Igs the is item deactivated
Alis.Core.Graphic.ImGui.ImGui.GetTreeNodeToLabelSpacing
static float GetTreeNodeToLabelSpacing()
Gets the tree node to label spacing
Definition: ImGui.cs:9612
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereX
static void SetScrollHereX()
Sets the scroll here x
Definition: ImGui.cs:16492
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, bool b)
Values the prefix
Definition: ImGui.cs:20823
Alis.Core.Graphic.ImGui.ImGui.SetScrollHereY
static void SetScrollHereY(float centerYRatio)
Sets the scroll here y using the specified center y ratio
Definition: ImGui.cs:16520
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin)
Describes whether drag int range 2
Definition: ImGui.cs:7589
Alis.Core.Graphic.ImGui.ImGui.TableSetupScrollFreeze
static void TableSetupScrollFreeze(int cols, int rows)
Tables the setup scroll freeze using the specified cols
Definition: ImGui.cs:20212
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetVersion
static byte * igGetVersion()
Igs the get version
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToDisk
static void SaveIniSettingsToDisk(string iniFilename)
Saves the ini settings to disk using the specified ini filename
Definition: ImGui.cs:15543
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushButtonRepeat
static void igPushButtonRepeat(byte repeat)
Igs the push button repeat using the specified repeat
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowFocused
static byte igIsWindowFocused(ImGuiFocus flag)
Igs the is window focused using the specified flags
Alis.Core.Graphic.ImGui.ImGui.IsPopupOpen
static bool IsPopupOpen(string strId)
Describes whether is popup open
Definition: ImGui.cs:12842
Alis.Core.Graphic.ImGui.ImGui.Button
static bool Button(string label)
Describes whether button
Definition: ImGui.cs:1861
Alis.Core.Graphic.ImGui.Enums.ImGuiButtons
ImGuiButtons
The im gui button flags enum
Definition: ImGuiButtons.cs:39
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v)
Describes whether drag int 3
Definition: ImGui.cs:6602
Alis.Core.Graphic.ImGui.ImGui.GetCursorScreenPos
static Vector2F GetCursorScreenPos()
Gets the cursor screen pos
Definition: ImGui.cs:9124
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckbox
static byte igCheckbox(byte *label, byte *v)
Igs the checkbox using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginCombo
static byte igBeginCombo(byte *label, byte *previewValue, ImGuiCombos flag)
Igs the begin combo using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt3
static byte igDragInt3(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the drag int 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column)
Describes whether begin table
Definition: ImGui.cs:1636
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopTabStop
static void igPopTabStop()
Igs the pop tab stop
Alis.Core.Graphic.ImGui.ImGui.SliderFloat4
static bool SliderFloat4(string label, ref Vector4F v, float vMin, float vMax)
Describes whether slider float 4
Definition: ImGui.cs:18180
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format)
Describes whether drag scalar
Definition: ImGui.cs:8225
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, byte[] buf, uint bufSize, ImGuiInputTexts flag)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCheckboxFlags_UintPtr
static byte igCheckboxFlags_UintPtr(byte *label, uint *flags, uint flagsValue)
Igs the checkbox flags uint ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax)
Describes whether slider float
Definition: ImGui.cs:17532
Alis.Core.Graphic.ImGui.ImGui.Dummy
static void Dummy(Vector2F size)
Dummies the size
Definition: ImGui.cs:8723
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragFloat3
static byte igDragFloat3(byte *label, Vector3F *v, float vSpeed, float vMin, float vMax, byte *format, ImGuiSliders flag)
Igs the drag float 3 using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetScrollMaxX
static float GetScrollMaxX()
Gets the scroll max x
Definition: ImGui.cs:9500
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFrameHeightWithSpacing
static float igGetFrameHeightWithSpacing()
Igs the get frame height with spacing
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClassPtr
The im gui window class ptr
Definition: ImGuiWindowClassPtr.cs:40
Alis.Core.Graphic.ImGui.ImGui.InputInt4
static bool InputInt4(string label, ref int v, ImGuiInputTexts flag)
Describes whether input int 4
Definition: ImGui.cs:11782
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDockSpace
static uint igDockSpace(uint id, Vector2F size, ImGuiDockNodes flag, ImGuiWindowClass *windowClass)
Igs the dock space using the specified id
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile(int autoOpenDepth)
Logs the to file using the specified auto open depth
Definition: ImGui.cs:13425
Alis.Core.Graphic.ImGui.ImGui.InputFloat2
static bool InputFloat2(string label, ref Vector2F v)
Describes whether input float 2
Definition: ImGui.cs:10747
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowHovered
static byte igIsWindowHovered(ImGuiHovereds flag)
Igs the is window hovered using the specified flags
Alis.Core.Graphic.ImGui.ImGui.InputInt2
static bool InputInt2(string label, ref int v, ImGuiInputTexts flag)
Describes whether input int 2
Definition: ImGui.cs:11606
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetSortSpecs
static ImGuiTableSortSpecs * igTableGetSortSpecs()
Igs the table get sort specs
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopup_Str
static void igOpenPopup_Str(byte *strId, ImGuiPopups popups)
Igs the open popup str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetDragDropPayload
static byte igSetDragDropPayload(byte *type, void *data, uint sz, ImGuiCond cond)
Igs the set drag drop payload using the specified type
Alis.Core.Graphic.ImGui.ImGui.IsMouseReleased
static bool IsMouseReleased(ImGuiMouseButton button)
Describes whether is mouse released
Definition: ImGui.cs:12831
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt2
static byte igInputInt2(byte *label, int *v, ImGuiInputTexts flag)
Igs the input int 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.LogText
static void LogText(string fmt)
Logs the text using the specified fmt
Definition: ImGui.cs:13361
Alis.Core.Graphic.ImGui.ImGui.SliderScalarN
static bool SliderScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, IntPtr pMin, IntPtr pMax)
Describes whether slider scalar n
Definition: ImGui.cs:19462
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igNewLine
static void igNewLine()
Igs the new line
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTabItemButton
static byte igTabItemButton(byte *label, ImGuiTabItems flag)
Igs the tab item button using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemID
static uint igGetItemID()
Igs the get item id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMousePosOnOpeningCurrentPopup
static void igGetMousePosOnOpeningCurrentPopup(Vector2F *pOut)
Igs the get mouse pos on opening current popup using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragScalar
static byte igDragScalar(byte *label, ImGuiDataType dataType, void *pData, float vSpeed, void *pMin, void *pMax, byte *format, ImGuiSliders flag)
Igs the drag scalar using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
Describes whether drag scalar
Definition: ImGui.cs:8303
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, float v, string floatFormat)
Values the prefix
Definition: ImGui.cs:20974
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleColor_Vec4
static void igPushStyleColor_Vec4(ImGuiCol idx, Vector4F col)
Igs the push style color vec 4 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.IsWindowFocused
static bool IsWindowFocused()
Describes whether is window focused
Definition: ImGui.cs:12974
Alis.Core.Graphic.ImGui.ImGui.StyleColorsLight
static void StyleColorsLight()
Styles the colors light
Definition: ImGui.cs:19743
Alis.Core.Graphic.ImGui.Enums.ImGuiTables
ImGuiTables
The im gui table flags enum
Definition: ImGuiTables.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetStyleColorVec4
static Vector4F * GetStyleColorVec4(ImGuiCol idx)
Gets the style color vec 4 using the specified idx
Definition: ImGui.cs:9572
Alis.Core.Graphic.ImGui.ImGui.InputDouble
static bool InputDouble(string label, ref double v, double step, double stepFast, string format, ImGuiInputTexts flag)
Describes whether input double
Definition: ImGui.cs:10328
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format)
Describes whether slider scalar
Definition: ImGui.cs:19310
Alis.Core.Graphic.ImGui.ImGui.PushStyleVar
static void PushStyleVar(ImGuiStyleVar idx, Vector2F val)
Pushes the style var using the specified idx
Definition: ImGui.cs:15332
Alis.Core.Graphic.ImGui.Enums.ImGuiCond
ImGuiCond
The im gui cond enum
Definition: ImGuiCond.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowSize
static void igGetWindowSize(Vector2F *pOut)
Igs the get window size using the specified p out
Alis.Core.Graphic.ImGui.ImGui.LogFinish
static void LogFinish()
Logs the finish
Definition: ImGui.cs:13352
Alis.Core.Graphic.ImGui.ImGui.EndCombo
static void EndCombo()
Ends the combo
Definition: ImGui.cs:8755
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowPos
static void SetNextWindowPos(Vector2F pos)
Sets the next window pos using the specified pos
Definition: ImGui.cs:16345
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollX_Float
static void igSetScrollX_Float(float scrollX)
Igs the set scroll x float using the specified scroll x
Alis.Core.Graphic.ImGui.ImGui.InputInt3
static bool InputInt3(string label, ref int v, ImGuiInputTexts flag)
Describes whether input int 3
Definition: ImGui.cs:11694
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut)
Describes whether menu item
Definition: ImGui.cs:13555
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginMenu
static byte igBeginMenu(byte *label, byte enabled)
Igs the begin menu using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetTime
static double GetTime()
Gets the time
Definition: ImGui.cs:9602
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPlotHistogram_FloatPtr
static void igPlotHistogram_FloatPtr(byte *label, float *values, int valuesCount, int valuesOffset, byte *overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Igs the plot histogram float ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTable
static void igEndTable()
Igs the end table
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetDragDropPayload
static ImGuiPayload * igGetDragDropPayload()
Igs the get drag drop payload
Alis.Core.Graphic.ImGui.ImGui.DragFloat4
static bool DragFloat4(string label, ref Vector4F v, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float 4
Definition: ImGui.cs:5027
Alis.Core.Graphic.ImGui.ImGui.TableGetSortSpecs
static ImGuiTableSortSpecsPtr TableGetSortSpecs()
Tables the get sort specs
Definition: ImGui.cs:19917
Alis.Core.Graphic.ImGui.Utils.Unsafe.CopyBlock
static unsafe void CopyBlock(void *destination, void *source, uint byteCount)
Copies bytes from the source address to the destination address.
Definition: Unsafe.cs:72
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowFocus
static void igSetNextWindowFocus()
Igs the set next window focus
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextWindow
static bool BeginPopupContextWindow()
Describes whether begin popup context window
Definition: ImGui.cs:1204
Alis.Core.Graphic.ImGui.Utils.Util.CalcSizeInUtf8
static int CalcSizeInUtf8(string s, int start, int length)
Calcs the size in utf 8 using the specified s
Definition: Util.cs:108
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePush_Ptr
static void igTreePush_Ptr(void *ptrId)
Igs the tree push ptr using the specified ptr id
Alis.Core.Graphic.ImGui.ImGui.PlotLines
static void PlotLines(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin)
Plots the lines using the specified label
Definition: ImGui.cs:14758
Alis.Core.Graphic.ImGui.ImGui.GetForegroundDrawList
static ImDrawListPtr GetForegroundDrawList()
Gets the foreground draw list
Definition: ImGui.cs:9207
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnsCount
static int igGetColumnsCount()
Igs the get columns count
Alis.Core.Graphic.ImGui.ImGui.EndTable
static void EndTable()
Ends the table
Definition: ImGui.cs:8859
Alis.Core.Graphic.ImGui.ImGui.SetScrollX
static void SetScrollX(float scrollX)
Sets the scroll x using the specified scroll x
Definition: ImGui.cs:16529
Alis.Core.Graphic.ImGui.ImGui.SameLine
static void SameLine(float offsetFromStartX)
Sames the line using the specified offset from start x
Definition: ImGui.cs:15523
Alis.Core.Graphic.ImGui.ImGui.EndMainMenuBar
static void EndMainMenuBar()
Ends the main menu bar
Definition: ImGui.cs:8811
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetCurrentContext
static void igSetCurrentContext(IntPtr ctx)
Igs the set current context using the specified ctx
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowHeight
static float igGetWindowHeight()
Igs the get window height
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetKeyboardFocusHere
static void igSetKeyboardFocusHere(int offset)
Igs the set keyboard focus here using the specified offset
Alis.Core.Graphic.ImGui.ImGui.GetUtf8Bytes
static byte * GetUtf8Bytes(string text)
Gets the utf 8 bytes using the specified text
Definition: ImGui.cs:22102
Alis.Core.Aspect.Math.Vector.Vector2F.Length
readonly float Length()
Returns the length of the vector.
Definition: Vector2F.cs:491
Alis.Core.Graphic.ImGui.ImGui.GetId
static uint GetId(IntPtr ptrId)
Gets the id using the specified ptr id
Definition: ImGui.cs:9299
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromDisk
static void LoadIniSettingsFromDisk(string iniFilename)
Loads the ini settings from disk using the specified ini filename
Definition: ImGui.cs:13235
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragInt2
static byte igDragInt2(byte *label, int *v, float vSpeed, int vMin, int vMax, byte *format, ImGuiSliders flag)
Igs the drag int 2 using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax)
Describes whether slider scalar
Definition: ImGui.cs:19261
Alis.Core.Graphic.ImGui.ImGui.CheckboxFlags
static bool CheckboxFlags(string label, ref uint flags, uint flagsValue)
Describes whether checkbox flags
Definition: ImGui.cs:2040
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushTabStop
static void igPushTabStop(byte tabStop)
Igs the push tab stop using the specified tab stop
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMainMenuBar
static void igEndMainMenuBar()
Igs the end main menu bar
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPushStyleColor_U32
static void igPushStyleColor_U32(ImGuiCol idx, uint col)
Igs the push style color u 32 using the specified idx
Alis.Core.Graphic.ImGui.ImGui.TextDisabled
static void TextDisabled(string fmt)
Texts the disabled using the specified fmt
Definition: ImGui.cs:20294
Alis.Core.Graphic.ImGui.ImGui.ColorEdit3
static bool ColorEdit3(string label, ref Vector3F col)
Describes whether color edit 3
Definition: ImGui.cs:2453
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format, ImGuiInputTexts flag)
Describes whether input scalar
Definition: ImGui.cs:12047
Alis.Core.Graphic.ImGui.ImGui.GetDrawData
static ImDrawDataPtr GetDrawData()
Gets the draw data
Definition: ImGui.cs:9156
Alis.Core.Graphic.ImGui.ImGui.SaveIniSettingsToMemory
static string SaveIniSettingsToMemory(out uint outIniSize)
Saves the ini settings to memory using the specified out ini size
Definition: ImGui.cs:15591
Alis.Core.Graphic.ImGui.ImGui.GetKeyIndex
static ImGuiKey GetKeyIndex(ImGuiKey key)
Gets the key index using the specified key
Definition: ImGui.cs:9364
Alis.Core.Graphic.ImGui.Enums.ImGuiWindows
ImGuiWindows
The im gui window flags enum
Definition: ImGuiWindows.cs:39
Alis.Core.Graphic.ImGui.ImGui.TreeNode
static bool TreeNode(string strId, string fmt)
Describes whether tree node
Definition: ImGui.cs:20444
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ref bool pVisible)
Describes whether collapsing header
Definition: ImGui.cs:2171
Alis.Core.Graphic.ImGui.ImGui.ColorPicker4
static bool ColorPicker4(string label, ref Vector4F col)
Describes whether color picker 4
Definition: ImGui.cs:2717
Alis.Core.Graphic.ImGui.ImGui.ShowFontSelector
static void ShowFontSelector(string label)
Shows the font selector using the specified label
Definition: ImGui.cs:17037
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetColorEditOptions
static void igSetColorEditOptions(ImGuiColorEdits flag)
Igs the set color edit options using the specified flags
Alis.Core.Graphic.ImGui.ImGui.IsItemClicked
static bool IsItemClicked()
Describes whether is item clicked
Definition: ImGui.cs:12556
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label)
Describes whether menu item
Definition: ImGui.cs:13512
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowDocked
static byte igIsWindowDocked()
Igs the is window docked
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igStyleColorsClassic
static void igStyleColorsClassic(ImGuiStyle *dst)
Igs the style colors classic using the specified dst
Alis.Core.Graphic.ImGui.ImGui.GetScrollY
static float GetScrollY()
Gets the scroll y
Definition: ImGui.cs:9530
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size)
Images the user texture id
Definition: ImGui.cs:9737
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowStackToolWindow
static void igShowStackToolWindow(byte *pOpen)
Igs the show stack tool window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginTooltip
static byte igBeginTooltip()
Igs the begin tooltip
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextItemOpen
static void igSetNextItemOpen(byte isOpen, ImGuiCond cond)
Igs the set next item open using the specified is open
Alis.Core.Graphic.ImGui.ImGui.AreUtf8StringsEqual
static bool AreUtf8StringsEqual(byte *utf8Bytes, string text)
Describes whether are utf 8 strings equal
Definition: ImGui.cs:22143
Alis.Core.Graphic.ImGui.ImGui.SetWindowCollapsed
static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
Sets the window collapsed using the specified collapsed
Definition: ImGui.cs:16641
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputFloat
static byte igInputFloat(byte *label, float *v, float step, float stepFast, byte *format, ImGuiInputTexts flag)
Igs the input float using the specified label
Alis.Core.Graphic.ImGui.ImGui.TableNextRow
static void TableNextRow(ImGuiTableRows rows, float minRowHeight)
Tables the next row using the specified row flags
Definition: ImGui.cs:20002
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax, string format)
Describes whether drag float range 2
Definition: ImGui.cs:5468
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorEdit4
static byte igColorEdit4(byte *label, Vector4F *col, ImGuiColorEdits flag)
Igs the color edit 4 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemVisible
static byte igIsItemVisible()
Igs the is item visible
Alis.Core.Graphic.ImGui.ImGui.StyleColorsDark
static void StyleColorsDark()
Styles the colors dark
Definition: ImGui.cs:19724
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igFindViewportByID
static ImGuiViewport * igFindViewportByID(uint id)
Igs the find viewport by id using the specified id
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTables flag, Vector2F outerSize, float innerWidth)
Describes whether begin table
Definition: ImGui.cs:1768
Alis.Core.Graphic.ImGui.ImGui.ShowStyleEditor
static void ShowStyleEditor(ImGuiStylePtr @ref)
Definition: ImGui.cs:17123
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowSize_Vec2
static void igSetWindowSize_Vec2(Vector2F size, ImGuiCond cond)
Igs the set window size vec 2 using the specified size
Alis.Core.Graphic.ImGui.ImGui.SetKeyboardFocusHere
static void SetKeyboardFocusHere(int offset)
Sets the keyboard focus here using the specified offset
Definition: ImGui.cs:16198
Alis.Core.Graphic.ImGui.ImGui.Columns
static void Columns(int count, string id)
Columnses the count
Definition: ImGui.cs:2876
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowUserGuide
static void igShowUserGuide()
Igs the show user guide
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnFlags
static ImGuiTableColumns TableGetColumnFlags()
Tables the get column flags
Definition: ImGui.cs:19853
Alis.Core.Graphic.ImGui.ImGui.DragInt4
static bool DragInt4(string label, ref int v, float vSpeed, int vMin, int vMax, string format, ImGuiSliders flag)
Describes whether drag int 4
Definition: ImGui.cs:7371
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, bool selected, ImGuiSelectables flag)
Describes whether selectable
Definition: ImGui.cs:15692
Alis.Core.Graphic.ImGui.ImGui.InputTextMultiline
static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2F size, ImGuiInputTexts flag, ImGuiInputTextCallback callback, IntPtr userData)
Determines whether the input text is multiline.
Definition: ImGui.cs:21924
Alis.Core.Graphic.ImGui.Structs.ImFontAtlas
The im font atlas
Definition: ImFontAtlas.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowWidth
static float igGetWindowWidth()
Igs the get window width
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputInt4
static byte igInputInt4(byte *label, int *v, ImGuiInputTexts flag)
Igs the input int 4 using the specified label
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount)
Plots the histogram using the specified label
Definition: ImGui.cs:14117
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCreateContext
static IntPtr igCreateContext(ImFontAtlas *sharedFontAtlas)
Igs the create context using the specified shared font atlas
Alis.Core.Graphic.ImGui.ImGui.SliderFloat3
static bool SliderFloat3(string label, ref Vector3F v, float vMin, float vMax)
Describes whether slider float 3
Definition: ImGui.cs:17964
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.ImGui.SetItemAllowOverlap
static void SetItemAllowOverlap()
Sets the item allow overlap
Definition: ImGui.cs:16172
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumns flag, float initWidthOrWeight, uint userId)
Tables the setup column using the specified label
Definition: ImGui.cs:20175
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igUpdatePlatformWindows
static void igUpdatePlatformWindows()
Igs the update platform windows
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowDemoWindow
static void igShowDemoWindow(byte *pOpen)
Igs the show demo window using the specified p open
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label)
Describes whether selectable
Definition: ImGui.cs:15605
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMenuItem_Bool
static byte igMenuItem_Bool(byte *label, byte *shortcut, byte selected, byte enabled)
Igs the menu item bool using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiStorage
The im gui storage
Definition: ImGuiStorage.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFont
static ImFont * igGetFont()
Igs the get font
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_StrStr
static byte igTreeNodeEx_StrStr(byte *strId, ImGuiTreeNodes flag, byte *fmt)
Igs the tree node ex str str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableNextRow
static void igTableNextRow(ImGuiTableRows rows, float minRowHeight)
Igs the table next row using the specified row flags
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsAnyMouseDown
static byte igIsAnyMouseDown()
Igs the is any mouse down
Alis.Core.Graphic.ImGui.Structs.ImGuiWindowClassPtr.NativePtr
ImGuiWindowClass * NativePtr
Gets the value of the native ptr
Definition: ImGuiWindowClassPtr.cs:44
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igText
static void igText(byte *fmt)
Igs the text using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ref bool pOpen, ImGuiWindows flag)
Describes whether begin
Definition: ImGui.cs:267
Alis.Core.Graphic.ImGui.ImGui.GetUtf8BytesLength
static int GetUtf8BytesLength(byte *utf8Bytes)
Gets the utf 8 bytes length using the specified utf 8 bytes
Definition: ImGui.cs:22174
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEnd
static void igEnd()
Igs the end
Alis.Core.Graphic.ImGui.ImGui.GetPlatformIo
static ImGuiPlatformIoPtr GetPlatformIo()
Gets the platform io
Definition: ImGui.cs:9490
Alis.Core.Graphic.ImGui.ImGui.ColorPicker3
static bool ColorPicker3(string label, ref Vector3F col)
Describes whether color picker 3
Definition: ImGui.cs:2629
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F bgCol, Vector4F tintCol)
Describes whether image button
Definition: ImGui.cs:9993
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseDragDelta
static void igGetMouseDragDelta(Vector2F *pOut, ImGuiMouseButton button, float lockThreshold)
Igs the get mouse drag delta using the specified p out
Alis.Core.Graphic.ImGui.ImGui.PushTabStop
static void PushTabStop(bool tabStop)
Pushes the tab stop using the specified tab stop
Definition: ImGui.cs:15341
Alis.Core.Graphic.ImGui.ImGui.MenuItem
static bool MenuItem(string label, string shortcut, ref bool pSelected)
Describes whether menu item
Definition: ImGui.cs:13769
Alis.Core.Graphic.ImGui.ImGui.EndDisabled
static void EndDisabled()
Ends the disabled
Definition: ImGui.cs:8763
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowPos_Vec2
static void igSetWindowPos_Vec2(Vector2F pos, ImGuiCond cond)
Igs the set window pos vec 2 using the specified pos
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset, string overlayText, float scaleMin, float scaleMax, Vector2F graphSize, int stride)
Plots the histogram using the specified label
Definition: ImGui.cs:14517
Alis.Core.Graphic.ImGui.ImGui.SmallButton
static bool SmallButton(string label)
Describes whether small button
Definition: ImGui.cs:19660
Alis.Core.Graphic.ImGui.ImGui.GetStateStorage
static ImGuiStoragePtr GetStateStorage()
Gets the state storage
Definition: ImGui.cs:9540
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColorU32_U32
static uint igGetColorU32_U32(uint col)
Igs the get color u 32 u 32 using the specified col
Alis.Core.Graphic.ImGui.ImGui.SetColumnOffset
static void SetColumnOffset(int columnIndex, float offsetX)
Sets the column offset using the specified column index
Definition: ImGui.cs:16023
Alis.Core.Graphic.ImGui.ImGui.BeginPopupModal
static bool BeginPopupModal(string name, ref bool pOpen)
Describes whether begin popup modal
Definition: ImGui.cs:1339
Alis.Core.Graphic.ImGui.ImGui.TableHeader
static void TableHeader(string label)
Tables the header using the specified label
Definition: ImGui.cs:19927
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollY_Float
static void igSetScrollY_Float(float scrollY)
Igs the set scroll y float using the specified scroll y
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndMenu
static void igEndMenu()
Igs the end menu
Alis.Core.Graphic.ImGui.ImGui.SetNextItemOpen
static void SetNextItemOpen(bool isOpen)
Sets the next item open using the specified is open
Definition: ImGui.cs:16236
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetKeyIndex
static ImGuiKey igGetKeyIndex(ImGuiKey key)
Igs the get key index using the specified key
Alis.Core.Graphic.ImGui.ImGui.GetColumnIndex
static int GetColumnIndex()
Gets the column index
Definition: ImGui.cs:8997
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetWindowFocus_Nil
static void igSetWindowFocus_Nil()
Igs the set window focus nil
Alis.Core.Graphic.ImGui.ImGui.PlotHistogram
static void PlotHistogram(string label, ref float values, int valuesCount, int valuesOffset)
Plots the histogram using the specified label
Definition: ImGui.cs:14165
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColorPicker4
static byte igColorPicker4(byte *label, Vector4F *col, ImGuiColorEdits flag, float *refCol)
Igs the color picker 4 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMouseCursor
static ImGuiMouseCursor igGetMouseCursor()
Igs the get mouse cursor
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1, Vector4F tintCol, Vector4F borderCol)
Images the user texture id
Definition: ImGui.cs:9797
Alis.Core.Graphic.ImGui.ImGui.GetVersion
static string GetVersion()
Gets the version
Definition: ImGui.cs:9622
Alis.Core.Graphic.ImGui.ImGui.RenderPlatformWindowsDefault
static void RenderPlatformWindowsDefault(IntPtr platformRenderArg)
Renders the platform windows default using the specified platform render arg
Definition: ImGui.cs:15472
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 2
Definition: ImGui.cs:6454
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCollapsingHeader_BoolPtr
static byte igCollapsingHeader_BoolPtr(byte *label, byte *pVisible, ImGuiTreeNodes flag)
Igs the collapsing header bool ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetContentRegionAvail
static void igGetContentRegionAvail(Vector2F *pOut)
Igs the get content region avail using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndChildFrame
static void igEndChildFrame()
Igs the end child frame
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(string strId)
Opens the popup using the specified str id
Definition: ImGui.cs:13937
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetTooltip
static void igSetTooltip(byte *fmt)
Igs the set tooltip using the specified fmt
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin, int vMax, string format)
Describes whether drag int 3
Definition: ImGui.cs:6874
Alis.Core.Graphic.ImGui.ImGui.TableSetupColumn
static void TableSetupColumn(string label, ImGuiTableColumns flag)
Tables the setup column using the specified label
Definition: ImGui.cs:20095
Alis.Core.Graphic.ImGui.ImGui.SetClipboardText
static void SetClipboardText(string text)
Sets the clipboard text using the specified text
Definition: ImGui.cs:15977
Alis.Core.Graphic.ImGui.ImGui.IsItemDeactivatedAfterEdit
static bool IsItemDeactivatedAfterEdit()
Describes whether is item deactivated after edit
Definition: ImGui.cs:12588
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_Str
static byte igTreeNodeEx_Str(byte *label, ImGuiTreeNodes flag)
Igs the tree node ex str using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNodeEx_Ptr
static byte igTreeNodeEx_Ptr(void *ptrId, ImGuiTreeNodes flag, byte *fmt)
Igs the tree node ex ptr using the specified ptr id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCloseCurrentPopup
static void igCloseCurrentPopup()
Igs the close current popup
Alis.Core.Graphic.ImGui.ImGui.LogToClipboard
static void LogToClipboard(int autoOpenDepth)
Logs the to clipboard using the specified auto open depth
Definition: ImGui.cs:13406
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreeNode_Str
static byte igTreeNode_Str(byte *label)
Igs the tree node str using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSmallButton
static byte igSmallButton(byte *label)
Igs the small button using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragInt2
static bool DragInt2(string label, ref int v, float vSpeed, int vMin, int vMax)
Describes whether drag int 2
Definition: ImGui.cs:6386
Alis.Core.Graphic.ImGui.ImGui.EndTabBar
static void EndTabBar()
Ends the tab bar
Definition: ImGui.cs:8843
Alis.Core.Graphic.ImGui.ImGui.DragInt3
static bool DragInt3(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int 3
Definition: ImGui.cs:6738
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igCalcItemWidth
static float igCalcItemWidth()
Igs the calc item width
Alis.Core.Graphic.ImGui.ImGui.SliderAngle
static bool SliderAngle(string label, ref float vRad)
Describes whether slider angle
Definition: ImGui.cs:17182
Alis.Core.Graphic.ImGui.ImGui.InputTextWithHint
static bool InputTextWithHint(string label, string hint, ref string input, uint maxLength, ImGuiInputTexts flag, ImGuiInputTextCallback callback)
Describes whether input text with hint
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextVoid
static bool BeginPopupContextVoid(string strId, ImGuiPopups popups)
Describes whether begin popup context void
Definition: ImGui.cs:1166
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableSetupScrollFreeze
static void igTableSetupScrollFreeze(int cols, int rows)
Igs the table setup scroll freeze using the specified cols
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v)
Describes whether input float 3
Definition: ImGui.cs:10957
Alis.Core.Graphic.ImGui.Structs.ImDrawList
The im draw list
Definition: ImDrawList.cs:39
Alis.Core.Graphic.ImGui.ImGui.InputFloat3
static bool InputFloat3(string label, ref Vector3F v, string format, ImGuiInputTexts flag)
Describes whether input float 3
Definition: ImGui.cs:11096
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetColumnWidth
static float igGetColumnWidth(int columnIndex)
Igs the get column width using the specified column index
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v, float vSpeed)
Describes whether drag float
Definition: ImGui.cs:3563
Alis.Core.Graphic.ImGui.ImGui.GetMouseDragDelta
static Vector2F GetMouseDragDelta(ImGuiMouseButton button, float lockThreshold)
Gets the mouse drag delta using the specified button
Definition: ImGui.cs:9457
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax)
Describes whether drag float range 2
Definition: ImGui.cs:5176
Alis.Core.Graphic.ImGui.ImGui.IsRectVisible
static bool IsRectVisible(Vector2F size)
Describes whether is rect visible
Definition: ImGui.cs:12922
Alis.Core.Graphic.ImGui.ImGui.VSliderInt
static bool VSliderInt(string label, Vector2F size, ref int v, int vMin, int vMax, string format)
Describes whether v slider int
Definition: ImGui.cs:21330
Alis.Core.Graphic.ImGui.ImGui.BeginTable
static bool BeginTable(string strId, int column, ImGuiTables flag)
Describes whether begin table
Definition: ImGui.cs:1680
Alis.Core.Graphic.ImGui.ImGui.PopTabStop
static void PopTabStop()
Pops the tab stop
Definition: ImGui.cs:15128
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size, ImGuiDockNodes flag)
Docks the space using the specified id
Definition: ImGui.cs:3411
Alis.Core.Graphic.ImGui.ImGui.IsMouseHoveringRect
static bool IsMouseHoveringRect(Vector2F rMin, Vector2F rMax)
Describes whether is mouse hovering rect
Definition: ImGui.cs:12780
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTextColored
static void igTextColored(Vector4F col, byte *fmt)
Igs the text colored using the specified col
Alis.Core.Graphic.ImGui.ImGui.ResetMouseDragDelta
static void ResetMouseDragDelta()
Resets the mouse drag delta
Definition: ImGui.cs:15494
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableHeader
static void igTableHeader(byte *label)
Igs the table header using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetMousePos
static void igGetMousePos(Vector2F *pOut)
Igs the get mouse pos using the specified p out
Alis.Core.Graphic.ImGui.Enums.ImGuiStyleVar
ImGuiStyleVar
The im gui style var enum
Definition: ImGuiStyleVar.cs:36
Alis.Core.Graphic.ImGui.ImGui.LogToTty
static void LogToTty(int autoOpenDepth)
Logs the to tty using the specified auto open depth
Definition: ImGui.cs:13481
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igProgressBar
static void igProgressBar(float fraction, Vector2F sizeArg, byte *overlay)
Igs the progress bar using the specified fraction
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igButton
static byte igButton(byte *label, Vector2F size)
Igs the button using the specified label
Alis.Core.Graphic.ImGui.ImGui.LogToFile
static void LogToFile()
Logs the to file
Definition: ImGui.cs:13414
Alis.Core.Graphic.ImGui.ImGui.TextColored
static void TextColored(Vector4F col, string fmt)
Texts the colored using the specified col
Definition: ImGui.cs:20258
Alis.Core.Graphic.ImGui.ImGui.IsMouseClicked
static bool IsMouseClicked(ImGuiMouseButton button, bool repeat)
Describes whether is mouse clicked
Definition: ImGui.cs:12721
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorStartPos
static void igGetCursorStartPos(Vector2F *pOut)
Igs the get cursor start pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnFlags
static ImGuiTableColumns igTableGetColumnFlags(int columnN)
Igs the table get column flags using the specified column n
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igUnindent
static void igUnindent(float indentW)
Igs the unindent using the specified indent w
Alis.Core.Graphic.ImGui.ImGui.TabItemButton
static bool TabItemButton(string label, ImGuiTabItems flag)
Describes whether tab item button
Definition: ImGui.cs:19805
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components, float vSpeed, IntPtr pMin, IntPtr pMax)
Describes whether drag scalar n
Definition: ImGui.cs:8524
Alis.Core.Graphic.ImGui.ImGui.Begin
static bool Begin(string name, ImGuiWindows flag)
Describes whether begin
Definition: ImGui.cs:22441
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsWindowCollapsed
static byte igIsWindowCollapsed()
Igs the is window collapsed
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndTabItem
static void igEndTabItem()
Igs the end tab item
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemToggledOpen
static byte igIsItemToggledOpen()
Igs the is item toggled open
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id)
Docks the space using the specified id
Definition: ImGui.cs:3381
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsMouseDragging
static byte igIsMouseDragging(ImGuiMouseButton button, float lockThreshold)
Igs the is mouse dragging using the specified button
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetPlatformIO
static ImGuiPlatformIo * igGetPlatformIO()
Igs the get platform io
Alis.Core.Graphic.ImGui.ImGui.IsWindowHovered
static bool IsWindowHovered(ImGuiHovereds flag)
Describes whether is window hovered
Definition: ImGui.cs:13008
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginPopup
static byte igBeginPopup(byte *strId, ImGuiWindows flag)
Igs the begin popup using the specified str id
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowFocus
static void SetNextWindowFocus()
Sets the next window focus
Definition: ImGui.cs:16336
Alis.Core.Graphic.ImGui.ImGui.BeginPopupContextItem
static bool BeginPopupContextItem()
Describes whether begin popup context item
Definition: ImGui.cs:1020
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v, float step, float stepFast)
Describes whether input float
Definition: ImGui.cs:10533
Alis.Core.Graphic.ImGui.ImGui.LoadIniSettingsFromMemory
static void LoadIniSettingsFromMemory(string iniData, uint iniSize)
Loads the ini settings from memory using the specified ini data
Definition: ImGui.cs:13309
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax)
Describes whether drag int range 2
Definition: ImGui.cs:7443
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size)
Docks the space using the specified id
Definition: ImGui.cs:3396
Alis.Core.Graphic.ImGui.ImGui.BeginChildFrame
static bool BeginChildFrame(uint id, Vector2F size)
Describes whether begin child frame
Definition: ImGui.cs:538
Alis.Core.Graphic.ImGui.ImGui.InputText
static bool InputText(string label, IntPtr buf, uint bufSize)
Describes whether input text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igShowMetricsWindow
static void igShowMetricsWindow(byte *pOpen)
Igs the show metrics window using the specified p open
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetScrollMaxY
static float igGetScrollMaxY()
Igs the get scroll max y
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowCollapsed
static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
Sets the next window collapsed using the specified collapsed
Definition: ImGui.cs:16298
Alis.Core.Graphic.ImGui.Enums.ImGuiTreeNodes
ImGuiTreeNodes
The im gui tree node flags enum
Definition: ImGuiTreeNodes.cs:39
Alis.Core.Graphic.ImGui.ImGui.GetMousePos
static Vector2F GetMousePos()
Gets the mouse pos
Definition: ImGui.cs:9468
Alis.Core.Graphic.ImGui.ImGui.TreeNodeEx
static bool TreeNodeEx(string label, ImGuiTreeNodes flag)
Describes whether tree node ex
Definition: ImGui.cs:20593
Alis.Core.Graphic.ImGui.ImGui.DragScalar
static bool DragScalar(string label, ImGuiDataType dataType, IntPtr pData, float vSpeed, IntPtr pMin, IntPtr pMax)
Describes whether drag scalar
Definition: ImGui.cs:8175
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetCursorScreenPos
static void igGetCursorScreenPos(Vector2F *pOut)
Igs the get cursor screen pos using the specified p out
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowSize
static void igSetNextWindowSize(Vector2F size, ImGuiCond cond)
Igs the set next window size using the specified size
Alis.Core.Graphic.ImGui.ImGui.SetScrollFromPosX
static void SetScrollFromPosX(float localX, float centerXRatio)
Sets the scroll from pos x using the specified local x
Definition: ImGui.cs:16464
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igAcceptDragDropPayload
static ImGuiPayload * igAcceptDragDropPayload(byte *type, ImGuiDragDrops flag)
Igs the accept drag drop payload using the specified type
Alis.Core.Graphic.ImGui.ImGui.TableGetColumnCount
static int TableGetColumnCount()
Tables the get column count
Definition: ImGui.cs:19843
Alis.Core.Graphic.ImGui.ImGui.BeginChildFrame
static bool BeginChildFrame(uint id, Vector2F size, ImGuiWindows flag)
Describes whether begin child frame
Definition: ImGui.cs:552
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowViewport
static void igSetNextWindowViewport(uint viewportId)
Igs the set next window viewport using the specified viewport id
Alis.Core.Graphic.ImGui.ImGui.DragFloatRange2
static bool DragFloatRange2(string label, ref float vCurrentMin, ref float vCurrentMax, float vSpeed, float vMin, float vMax)
Describes whether drag float range 2
Definition: ImGui.cs:5395
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igRadioButton_IntPtr
static byte igRadioButton_IntPtr(byte *label, int *v, int vButton)
Igs the radio button int ptr using the specified label
Alis.Core.Graphic.ImGui.ImGui.CalcTextSizeImpl
static Vector2F CalcTextSizeImpl(string text, int start=0, int? length=null, bool hideTextAfterDoubleHash=false, float wrapWidth=-1.0f)
Calcs the text size impl using the specified text
Definition: ImGui.cs:22309
Alis.Core.Graphic.ImGui.ImGui.SetAllocatorFunctions
static void SetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, IntPtr userData)
Sets the allocator functions using the specified alloc func
Definition: ImGui.cs:15967
Alis.Core.Graphic.ImGui.ImGui.DockSpace
static uint DockSpace(uint id, Vector2F size, ImGuiDockNodes flag, ImGuiWindowClassPtr windowClass)
Docks the space using the specified id
Definition: ImGui.cs:3426
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId, Vector2F size)
Describes whether begin child
Definition: ImGui.cs:352
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pStep, IntPtr pStepFast, string format)
Describes whether input scalar
Definition: ImGui.cs:11970
Alis.Core.Graphic.ImGui.ImGui.InputFloat
static bool InputFloat(string label, ref float v)
Describes whether input float
Definition: ImGui.cs:10399
Alis.Core.Graphic.ImGui.ImGui.Indent
static void Indent(float indentW)
Indents the indent w
Definition: ImGui.cs:10040
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsItemFocused
static byte igIsItemFocused()
Igs the is item focused
Alis.Core.Graphic.ImGui.ImGui.InputScalar
static bool InputScalar(string label, ImGuiDataType dataType, IntPtr pData)
Describes whether input scalar
Definition: ImGui.cs:11826
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragScalarN
static byte igDragScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, float vSpeed, void *pMin, void *pMax, byte *format, ImGuiSliders flag)
Igs the drag scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected, ImGuiSelectables flag)
Describes whether selectable
Definition: ImGui.cs:15823
Alis.Core.Graphic.ImGui.ImGui.Selectable
static bool Selectable(string label, ref bool pSelected, ImGuiSelectables flag, Vector2F size)
Describes whether selectable
Definition: ImGui.cs:15869
Alis.Core.Graphic.ImGui.ImGui.IsKeyPressed
static bool IsKeyPressed(ImGuiKey key)
Describes whether is key pressed
Definition: ImGui.cs:12672
Alis.Core.Graphic.ImGui.ImGui.PopStyleColor
static void PopStyleColor()
Pops the style color
Definition: ImGui.cs:15092
Alis.Core.Graphic.ImGui.ImGui.NextColumn
static void NextColumn()
Nexts the column
Definition: ImGui.cs:13928
Alis.Core.Graphic.ImGui.ImGui.IsItemClicked
static bool IsItemClicked(ImGuiMouseButton mouseButton)
Describes whether is item clicked
Definition: ImGui.cs:12568
Alis.Core.Graphic.ImGui.Enums.ImGuiTabItems
ImGuiTabItems
The im gui tab item flags enum
Definition: ImGuiTabItems.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputScalar
static byte igInputScalar(byte *label, ImGuiDataType dataType, void *pData, void *pStep, void *pStepFast, byte *format, ImGuiInputTexts flag)
Igs the input scalar using the specified label
Alis.Core.Graphic.ImGui.ImGui.BeginChild
static bool BeginChild(string strId)
Describes whether begin child
Definition: ImGui.cs:309
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col)
Describes whether color button
Definition: ImGui.cs:2259
Alis.Core.Graphic.ImGui.Enums.ImGuiSliders
ImGuiSliders
The im gui slider flags enum
Definition: ImGuiSliders.cs:39
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetFontTexUvWhitePixel
static void igGetFontTexUvWhitePixel(Vector2F *pOut)
Igs the get font tex uv white pixel using the specified p out
Alis.Core.Graphic.ImGui.ImGui.PushStyleColor
static void PushStyleColor(ImGuiCol idx, Vector4F col)
Pushes the style color using the specified idx
Definition: ImGui.cs:15312
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSizeConstraints
static void SetNextWindowSizeConstraints(Vector2F sizeMin, Vector2F sizeMax, ImGuiSizeCallback customCallback, IntPtr customCallbackData)
Sets the next window size constraints using the specified size min
Definition: ImGui.cs:16434
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetAllocatorFunctions
static void igSetAllocatorFunctions(IntPtr allocFunc, IntPtr freeFunc, void *userData)
Igs the set allocator functions using the specified alloc func
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSeparator
static void igSeparator()
Igs the separator
Alis.Core.Graphic.ImGui.ImGui.BeginPopup
static bool BeginPopup(string strId)
Describes whether begin popup
Definition: ImGui.cs:941
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSeparatorText
static void igSeparatorText(byte *label)
Igs the separator text using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginGroup
static void igBeginGroup()
Igs the begin group
Alis.Core.Graphic.ImGui.Structs.ImFont
The im font
Definition: ImFont.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSaveIniSettingsToMemory
static byte * igSaveIniSettingsToMemory(uint *outIniSize)
Igs the save ini settings to memory using the specified out ini size
Alis.Core.Graphic.ImGui.Enums.ImGuiDataType
ImGuiDataType
The im gui data type enum
Definition: ImGuiDataType.cs:36
Alis.Core.Graphic.ImGui.ImGui.TableSetBgColor
static void TableSetBgColor(ImGuiTableBgTarget target, uint color, int columnN)
Tables the set bg color using the specified target
Definition: ImGui.cs:20024
Alis.Core.Graphic.ImGui.ImGui.BeginDragDropSource
static bool BeginDragDropSource()
Describes whether begin drag drop source
Definition: ImGui.cs:719
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTableGetColumnCount
static int igTableGetColumnCount()
Igs the table get column count
Alis.Core.Graphic.ImGui.ImGui.ListBox
static bool ListBox(string label, ref int currentItem, string[] items, int itemsCount)
Describes whether list box
Definition: ImGui.cs:13087
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePush_Str
static void igTreePush_Str(byte *strId)
Igs the tree push str using the specified str id
Alis.Core.Graphic.ImGui.ImGui.ImageButton
static bool ImageButton(string strId, IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
Describes whether image button
Definition: ImGui.cs:9901
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetNextWindowDockID
static void igSetNextWindowDockID(uint dockId, ImGuiCond cond)
Igs the set next window dock id using the specified dock id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetForegroundDrawList_ViewportPtr
static ImDrawList * igGetForegroundDrawList_ViewportPtr(ImGuiViewport *viewport)
Igs the get foreground draw list viewport ptr using the specified viewport
Alis.Core.Graphic.ImGui.ImGui.InputFloat4
static bool InputFloat4(string label, ref Vector4F v, string format, ImGuiInputTexts flag)
Describes whether input float 4
Definition: ImGui.cs:11306
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igColumns
static void igColumns(int count, byte *id, byte border)
Igs the columns using the specified count
Alis.Core.Aspect.Math
Definition: ArgumentExceptionDestinationTooShort.cs:33
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igMenuItem_BoolPtr
static byte igMenuItem_BoolPtr(byte *label, byte *shortcut, byte *pSelected, byte enabled)
Igs the menu item bool ptr using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetItemRectMax
static void igGetItemRectMax(Vector2F *pOut)
Igs the get item rect max using the specified p out
Alis.Core.Graphic.ImGui.ImGui.CalcTextSize
static Vector2F CalcTextSize(string text)
Calcs the text size using the specified text
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDebugTextEncoding
static void igDebugTextEncoding(byte *text)
Igs the debug text encoding using the specified text
Alis.Core.Graphic.ImGui.ImGui
The im gui class
Definition: ImGui.cs:46
Alis.Core.Graphic.ImGui.ImGui.DragFloat
static bool DragFloat(string label, ref float v)
Describes whether drag float
Definition: ImGui.cs:3495
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igGetWindowPos
static void igGetWindowPos(Vector2F *pOut)
Igs the get window pos using the specified p out
Alis.Core.Graphic.ImGui.ImGui.CollapsingHeader
static bool CollapsingHeader(string label, ref bool pVisible, ImGuiTreeNodes flag)
Describes whether collapsing header
Definition: ImGui.cs:2216
Alis.Core.Graphic.ImGui.ImGui.InvisibleButton
static bool InvisibleButton(string strId, Vector2F size, ImGuiButtons flag)
Describes whether invisible button
Definition: ImGui.cs:12458
Alis.Core.Graphic.ImGui.ImGui.BeginMainMenuBar
static bool BeginMainMenuBar()
Describes whether begin main menu bar
Definition: ImGui.cs:839
Alis.Core.Graphic.ImGui.ImGui.GetColumnWidth
static float GetColumnWidth()
Gets the column width
Definition: ImGui.cs:9039
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndListBox
static void igEndListBox()
Igs the end list box
Alis.Core.Graphic.ImGui.ImGui.TableSetColumnEnabled
static void TableSetColumnEnabled(int columnN, bool v)
Tables the set column enabled using the specified column n
Definition: ImGui.cs:20034
Alis.Core.Graphic.ImGui.ImGui.OpenPopup
static void OpenPopup(uint id, ImGuiPopups popups)
Opens the popup using the specified id
Definition: ImGui.cs:14022
Alis.Core.Graphic.ImGui.ImGui.SetCurrentContext
static void SetCurrentContext(IntPtr ctx)
Sets the current context using the specified ctx
Definition: ImGui.cs:16042
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputTextMultiline
static byte igInputTextMultiline(byte *label, byte *buf, uint bufSize, Vector2F size, ImGuiInputTexts flag, ImGuiInputTextCallback callback, void *userData)
Igs the input text multiline using the specified label
Alis.Core.Graphic.ImGui.ImGui.GetStyle
static ImGuiStylePtr GetStyle()
Gets the style
Definition: ImGui.cs:9550
Alis.Core.Graphic.ImGui.ImGui.ColorButton
static bool ColorButton(string descId, Vector4F col, ImGuiColorEdits flag, Vector2F size)
Describes whether color button
Definition: ImGui.cs:2345
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igIsKeyReleased_Nil
static byte igIsKeyReleased_Nil(ImGuiKey key)
Igs the is key released nil using the specified key
Alis.Core.Graphic.ImGui.ImGui.ProgressBar
static void ProgressBar(float fraction)
Progresses the bar using the specified fraction
Definition: ImGui.cs:15145
Alis.Core.Graphic.ImGui.Enums.ImGuiMouseButton
ImGuiMouseButton
The im gui mouse button enum
Definition: ImGuiMouseButton.cs:36
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igEndDragDropTarget
static void igEndDragDropTarget()
Igs the end drag drop target
Alis.Core.Graphic.ImGui.Structs.ImFontAtlasPtr
The im font atlas ptr
Definition: ImFontAtlasPtr.cs:42
Alis.Core.Graphic.ImGui.ImGui.DragIntRange2
static bool DragIntRange2(string label, ref int vCurrentMin, ref int vCurrentMax, float vSpeed, int vMin, int vMax, string format, string formatMax)
Describes whether drag int range 2
Definition: ImGui.cs:7817
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igBeginChild_Str
static byte igBeginChild_Str(byte *strId, Vector2F size, byte border, ImGuiWindows flag)
Igs the begin child str using the specified str id
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSliderScalarN
static byte igSliderScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, void *pMin, void *pMax, byte *format, ImGuiSliders flag)
Igs the slider scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.SliderScalar
static bool SliderScalar(string label, ImGuiDataType dataType, IntPtr pData, IntPtr pMin, IntPtr pMax, string format, ImGuiSliders flag)
Describes whether slider scalar
Definition: ImGui.cs:19387
Alis.Core.Graphic.ImGui.ImGui.Image
static void Image(IntPtr userTextureId, Vector2F size, Vector2F uv0, Vector2F uv1)
Images the user texture id
Definition: ImGui.cs:9767
Alis.Core.Graphic.ImGui.ImGui.DragFloat3
static bool DragFloat3(string label, ref Vector3F v)
Describes whether drag float 3
Definition: ImGui.cs:4335
Alis.Core.Graphic.ImGui.ImGui.SliderFloat
static bool SliderFloat(string label, ref float v, float vMin, float vMax, string format)
Describes whether slider float
Definition: ImGui.cs:17599
Alis.Core.Graphic.ImGui.ImGui.InputInt
static bool InputInt(string label, ref int v, int step, int stepFast, ImGuiInputTexts flag)
Describes whether input int
Definition: ImGui.cs:11518
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igInputScalarN
static byte igInputScalarN(byte *label, ImGuiDataType dataType, void *pData, int components, void *pStep, void *pStepFast, byte *format, ImGuiInputTexts flag)
Igs the input scalar n using the specified label
Alis.Core.Graphic.ImGui.ImGui.DragInt
static bool DragInt(string label, ref int v, float vSpeed, int vMin)
Describes whether drag int
Definition: ImGui.cs:5898
Alis.Core.Graphic.ImGui.ImGui.Value
static void Value(string prefix, uint v)
Values the prefix
Definition: ImGui.cs:20898
Alis.Core.Graphic.ImGui.ImGui.PushTextWrapPos
static void PushTextWrapPos()
Pushes the text wrap pos
Definition: ImGui.cs:15350
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igPopStyleVar
static void igPopStyleVar(int count)
Igs the pop style var using the specified count
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igDragIntRange2
static byte igDragIntRange2(byte *label, int *vCurrentMin, int *vCurrentMax, float vSpeed, int vMin, int vMax, byte *format, byte *formatMax, ImGuiSliders flag)
Igs the drag int range 2 using the specified label
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igTreePop
static void igTreePop()
Igs the tree pop
Alis.Core.Graphic.ImGui.Enums.ImGuiDockNodes
ImGuiDockNodes
The im gui dock node flags enum
Definition: ImGuiDockNodes.cs:39
Alis.Core.Graphic.ImGui.ImGui.InputInt2
static bool InputInt2(string label, ref int v)
Describes whether input int 2
Definition: ImGui.cs:11561
Alis.Core.Aspect.Math.Vector.Vector2F
The vector
Definition: Vector2F.cs:46
Alis.Core.Graphic.ImGui.ImGui.PushStyleColor
static void PushStyleColor(ImGuiCol idx, uint col)
Pushes the style color using the specified idx
Definition: ImGui.cs:15302
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igSetScrollFromPosX_Float
static void igSetScrollFromPosX_Float(float localX, float centerXRatio)
Igs the set scroll from pos x float using the specified local x
Alis.Core.Graphic.ImGui.Structs.ImGuiStylePtr
The im gui style ptr
Definition: ImGuiStylePtr.cs:41
Alis.Core.Graphic.ImGui.ImGui.DragScalarN
static bool DragScalarN(string label, ImGuiDataType dataType, IntPtr pData, int components)
Describes whether drag scalar n
Definition: ImGui.cs:8376
Alis.Core.Graphic.ImGui.ImGui.SetNextWindowSize
static void SetNextWindowSize(Vector2F size)
Sets the next window size using the specified size
Definition: ImGui.cs:16387
Alis.Core.Graphic.ImGui.Structs.ImGuiStylePtr.NativePtr
ImGuiStyle * NativePtr
Gets the value of the native ptr
Definition: ImGuiStylePtr.cs:45
Alis.Core.Graphic.ImGui.Structs.ImGuiNative.igOpenPopup_ID
static void igOpenPopup_ID(uint id, ImGuiPopups popups)
Igs the open popup id using the specified id
Alis.Core.Aspect.Math.Vector.Vector3F
The vector
Definition: Vector3F.cs:46